diff --git a/Duckling/AmountOfMoney/AR/Corpus.hs b/Duckling/AmountOfMoney/AR/Corpus.hs --- a/Duckling/AmountOfMoney/AR/Corpus.hs +++ b/Duckling/AmountOfMoney/AR/Corpus.hs @@ -21,7 +21,8 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale AR Nothing}, allExamples) +corpus = (testContext {locale = makeLocale AR Nothing}, + testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/AmountOfMoney/AR/Rules.hs b/Duckling/AmountOfMoney/AR/Rules.hs --- a/Duckling/AmountOfMoney/AR/Rules.hs +++ b/Duckling/AmountOfMoney/AR/Rules.hs @@ -7,6 +7,7 @@ {-# LANGUAGE GADTs #-} +{-# LANGUAGE LambdaCase #-} {-# LANGUAGE OverloadedStrings #-} module Duckling.AmountOfMoney.AR.Rules @@ -28,6 +29,20 @@ import qualified Duckling.AmountOfMoney.Types as TAmountOfMoney import qualified Duckling.Numeral.Types as TNumeral +ruleUnitAmount :: Rule +ruleUnitAmount = Rule + { name = " " + , pattern = + [ Predicate isCurrencyOnly + , Predicate isPositive + ] + , prod = \case + (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.currency = c}: + Token Numeral NumeralData{TNumeral.value = v}: + _) -> Just . Token AmountOfMoney . withValue v $ currencyOnly c + _ -> Nothing + } + rulePounds :: Rule rulePounds = Rule { name = "£" @@ -373,7 +388,8 @@ rules :: [Rule] rules = - [ ruleCent + [ ruleUnitAmount + , ruleCent , rulePounds , ruleDinars , ruleDirhams diff --git a/Duckling/AmountOfMoney/BG/Corpus.hs b/Duckling/AmountOfMoney/BG/Corpus.hs --- a/Duckling/AmountOfMoney/BG/Corpus.hs +++ b/Duckling/AmountOfMoney/BG/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale BG Nothing}, allExamples) +corpus = (testContext {locale = makeLocale BG Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/AmountOfMoney/BG/Rules.hs b/Duckling/AmountOfMoney/BG/Rules.hs --- a/Duckling/AmountOfMoney/BG/Rules.hs +++ b/Duckling/AmountOfMoney/BG/Rules.hs @@ -7,6 +7,7 @@ {-# LANGUAGE GADTs #-} +{-# LANGUAGE LambdaCase #-} {-# LANGUAGE OverloadedStrings #-} module Duckling.AmountOfMoney.BG.Rules @@ -16,18 +17,30 @@ import Data.Maybe import Data.String import Prelude -import qualified Data.Text as Text import Duckling.AmountOfMoney.Helpers import Duckling.AmountOfMoney.Types (Currency(..), AmountOfMoneyData (..)) import Duckling.Dimensions.Types import Duckling.Numeral.Helpers (isNatural, isPositive) import Duckling.Numeral.Types (NumeralData (..)) -import Duckling.Regex.Types import Duckling.Types import qualified Duckling.AmountOfMoney.Types as TAmountOfMoney import qualified Duckling.Numeral.Types as TNumeral +ruleUnitAmount :: Rule +ruleUnitAmount = Rule + { name = " " + , pattern = + [ Predicate isCurrencyOnly + , Predicate isPositive + ] + , prod = \case + (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.currency = c}: + Token Numeral NumeralData{TNumeral.value = v}: + _) -> Just . Token AmountOfMoney . withValue v $ currencyOnly c + _ -> Nothing + } + ruleBGN :: Rule ruleBGN = Rule { name = "лв" @@ -255,7 +268,8 @@ rules :: [Rule] rules = - [ ruleBGN + [ ruleUnitAmount + , ruleBGN , ruleDollar , ruleCent , ruleEUR diff --git a/Duckling/AmountOfMoney/EN/Corpus.hs b/Duckling/AmountOfMoney/EN/Corpus.hs --- a/Duckling/AmountOfMoney/EN/Corpus.hs +++ b/Duckling/AmountOfMoney/EN/Corpus.hs @@ -20,14 +20,14 @@ import Duckling.Testing.Types negativeCorpus :: NegativeCorpus -negativeCorpus = (testContext, examples) +negativeCorpus = (testContext, testOptions, examples) where examples = [ "exactly dollars" ] corpus :: Corpus -corpus = (testContext, allExamples) +corpus = (testContext, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/AmountOfMoney/EN/Rules.hs b/Duckling/AmountOfMoney/EN/Rules.hs --- a/Duckling/AmountOfMoney/EN/Rules.hs +++ b/Duckling/AmountOfMoney/EN/Rules.hs @@ -7,6 +7,7 @@ {-# LANGUAGE GADTs #-} +{-# LANGUAGE LambdaCase #-} {-# LANGUAGE OverloadedStrings #-} module Duckling.AmountOfMoney.EN.Rules @@ -28,6 +29,20 @@ import qualified Duckling.AmountOfMoney.Types as TAmountOfMoney import qualified Duckling.Numeral.Types as TNumeral +ruleUnitAmount :: Rule +ruleUnitAmount = Rule + { name = " " + , pattern = + [ Predicate isCurrencyOnly + , Predicate isPositive + ] + , prod = \case + (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.currency = c}: + Token Numeral NumeralData{TNumeral.value = v}: + _) -> Just . Token AmountOfMoney . withValue v $ currencyOnly c + _ -> Nothing + } + rulePounds :: Rule rulePounds = Rule { name = "£" @@ -310,7 +325,8 @@ rules :: [Rule] rules = - [ ruleACurrency + [ ruleUnitAmount + , ruleACurrency , ruleBucks , ruleCent , ruleDinars diff --git a/Duckling/AmountOfMoney/ES/Corpus.hs b/Duckling/AmountOfMoney/ES/Corpus.hs --- a/Duckling/AmountOfMoney/ES/Corpus.hs +++ b/Duckling/AmountOfMoney/ES/Corpus.hs @@ -21,7 +21,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale ES Nothing}, allExamples) +corpus = (testContext {locale = makeLocale ES Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/AmountOfMoney/ES/Rules.hs b/Duckling/AmountOfMoney/ES/Rules.hs --- a/Duckling/AmountOfMoney/ES/Rules.hs +++ b/Duckling/AmountOfMoney/ES/Rules.hs @@ -7,6 +7,7 @@ {-# LANGUAGE GADTs #-} +{-# LANGUAGE LambdaCase #-} {-# LANGUAGE OverloadedStrings #-} module Duckling.AmountOfMoney.ES.Rules @@ -20,12 +21,26 @@ import Duckling.AmountOfMoney.Helpers import Duckling.AmountOfMoney.Types (Currency(..), AmountOfMoneyData (..)) import Duckling.Dimensions.Types -import Duckling.Numeral.Helpers (isNatural) +import Duckling.Numeral.Helpers (isNatural, isPositive) import Duckling.Numeral.Types (NumeralData (..)) import Duckling.Types import qualified Duckling.AmountOfMoney.Types as TAmountOfMoney import qualified Duckling.Numeral.Types as TNumeral +ruleUnitAmount :: Rule +ruleUnitAmount = Rule + { name = " " + , pattern = + [ Predicate isCurrencyOnly + , Predicate isPositive + ] + , prod = \case + (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.currency = c}: + Token Numeral NumeralData{TNumeral.value = v}: + _) -> Just . Token AmountOfMoney . withValue v $ currencyOnly c + _ -> Nothing + } + ruleDollar :: Rule ruleDollar = Rule { name = "dollar" @@ -115,7 +130,8 @@ rules :: [Rule] rules = - [ ruleCent + [ ruleUnitAmount + , ruleCent , ruleDollar , ruleIntersect , ruleIntersectAndNumeral diff --git a/Duckling/AmountOfMoney/FR/Corpus.hs b/Duckling/AmountOfMoney/FR/Corpus.hs --- a/Duckling/AmountOfMoney/FR/Corpus.hs +++ b/Duckling/AmountOfMoney/FR/Corpus.hs @@ -21,7 +21,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale FR Nothing}, allExamples) +corpus = (testContext {locale = makeLocale FR Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/AmountOfMoney/FR/Rules.hs b/Duckling/AmountOfMoney/FR/Rules.hs --- a/Duckling/AmountOfMoney/FR/Rules.hs +++ b/Duckling/AmountOfMoney/FR/Rules.hs @@ -7,6 +7,7 @@ {-# LANGUAGE GADTs #-} +{-# LANGUAGE LambdaCase #-} {-# LANGUAGE OverloadedStrings #-} module Duckling.AmountOfMoney.FR.Rules @@ -26,6 +27,20 @@ import qualified Duckling.AmountOfMoney.Types as TAmountOfMoney import qualified Duckling.Numeral.Types as TNumeral +ruleUnitAmount :: Rule +ruleUnitAmount = Rule + { name = " " + , pattern = + [ Predicate isCurrencyOnly + , Predicate isPositive + ] + , prod = \case + (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.currency = c}: + Token Numeral NumeralData{TNumeral.value = v}: + _) -> Just . Token AmountOfMoney . withValue v $ currencyOnly c + _ -> Nothing + } + ruleIntersectAndNumeral :: Rule ruleIntersectAndNumeral = Rule { name = "intersect (and number)" @@ -242,7 +257,8 @@ rules :: [Rule] rules = - [ ruleCent + [ ruleUnitAmount + , ruleCent , ruleIntersect , ruleIntersectAndNumeral , ruleIntersectAndXCents diff --git a/Duckling/AmountOfMoney/GA/Corpus.hs b/Duckling/AmountOfMoney/GA/Corpus.hs --- a/Duckling/AmountOfMoney/GA/Corpus.hs +++ b/Duckling/AmountOfMoney/GA/Corpus.hs @@ -21,7 +21,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale GA Nothing}, allExamples) +corpus = (testContext {locale = makeLocale GA Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/AmountOfMoney/GA/Rules.hs b/Duckling/AmountOfMoney/GA/Rules.hs --- a/Duckling/AmountOfMoney/GA/Rules.hs +++ b/Duckling/AmountOfMoney/GA/Rules.hs @@ -7,6 +7,7 @@ {-# LANGUAGE GADTs #-} +{-# LANGUAGE LambdaCase #-} {-# LANGUAGE OverloadedStrings #-} module Duckling.AmountOfMoney.GA.Rules @@ -20,12 +21,26 @@ import Duckling.AmountOfMoney.Helpers import Duckling.AmountOfMoney.Types (Currency (..), AmountOfMoneyData (..)) import Duckling.Dimensions.Types -import Duckling.Numeral.Helpers (isNatural) +import Duckling.Numeral.Helpers (isNatural, isPositive) import Duckling.Numeral.Types (NumeralData (..)) import Duckling.Types import qualified Duckling.AmountOfMoney.Types as TAmountOfMoney import qualified Duckling.Numeral.Types as TNumeral +ruleUnitAmount :: Rule +ruleUnitAmount = Rule + { name = " " + , pattern = + [ Predicate isCurrencyOnly + , Predicate isPositive + ] + , prod = \case + (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.currency = c}: + Token Numeral NumeralData{TNumeral.value = v}: + _) -> Just . Token AmountOfMoney . withValue v $ currencyOnly c + _ -> Nothing + } + ruleDollar :: Rule ruleDollar = Rule { name = "$" @@ -148,7 +163,8 @@ rules :: [Rule] rules = - [ ruleAmountofmoneyGlan + [ ruleUnitAmount + , ruleAmountofmoneyGlan , ruleCent , ruleDollar , ruleInr diff --git a/Duckling/AmountOfMoney/HR/Corpus.hs b/Duckling/AmountOfMoney/HR/Corpus.hs --- a/Duckling/AmountOfMoney/HR/Corpus.hs +++ b/Duckling/AmountOfMoney/HR/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale HR Nothing}, allExamples) +corpus = (testContext {locale = makeLocale HR Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/AmountOfMoney/HR/Rules.hs b/Duckling/AmountOfMoney/HR/Rules.hs --- a/Duckling/AmountOfMoney/HR/Rules.hs +++ b/Duckling/AmountOfMoney/HR/Rules.hs @@ -6,6 +6,7 @@ -- of patent rights can be found in the PATENTS file in the same directory. {-# LANGUAGE GADTs #-} +{-# LANGUAGE LambdaCase #-} {-# LANGUAGE OverloadedStrings #-} module Duckling.AmountOfMoney.HR.Rules @@ -21,13 +22,27 @@ import Duckling.AmountOfMoney.Helpers import Duckling.AmountOfMoney.Types (Currency(..), AmountOfMoneyData (..)) import Duckling.Dimensions.Types -import Duckling.Numeral.Helpers (isNatural) +import Duckling.Numeral.Helpers (isNatural, isPositive) import Duckling.Numeral.Types (NumeralData (..)) import Duckling.Regex.Types import Duckling.Types import qualified Duckling.AmountOfMoney.Types as TAmountOfMoney import qualified Duckling.Numeral.Types as TNumeral +ruleUnitAmount :: Rule +ruleUnitAmount = Rule + { name = " " + , pattern = + [ Predicate isCurrencyOnly + , Predicate isPositive + ] + , prod = \case + (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.currency = c}: + Token Numeral NumeralData{TNumeral.value = v}: + _) -> Just . Token AmountOfMoney . withValue v $ currencyOnly c + _ -> Nothing + } + ruleIntersectAndNumber :: Rule ruleIntersectAndNumber = Rule { name = "intersect (and number)" @@ -185,7 +200,8 @@ rules :: [Rule] rules = - [ ruleDollar + [ ruleUnitAmount + , ruleDollar , rulePound , ruleOtherPounds , ruleAed diff --git a/Duckling/AmountOfMoney/Helpers.hs b/Duckling/AmountOfMoney/Helpers.hs --- a/Duckling/AmountOfMoney/Helpers.hs +++ b/Duckling/AmountOfMoney/Helpers.hs @@ -12,7 +12,11 @@ module Duckling.AmountOfMoney.Helpers ( currencyOnly , financeWith + , isSimpleAmountOfMoney + , isCent , isCents + , isCurrencyOnly + , isDime , isMoneyWithValue , isWithoutCents , withCents @@ -27,7 +31,7 @@ import Prelude import Duckling.AmountOfMoney.Types (Currency (..), AmountOfMoneyData (..)) -import Duckling.Numeral.Types (isInteger) +import Duckling.Numeral.Types (getIntValue, isInteger) import Duckling.Dimensions.Types import Duckling.Types hiding (Entity(..)) @@ -53,6 +57,28 @@ isMoneyWithValue (Token AmountOfMoney AmountOfMoneyData{value = v1, minValue = v2, maxValue = v3}) = any isJust [v1, v2, v3] isMoneyWithValue _ = False + +isCurrencyOnly :: Predicate +isCurrencyOnly (Token AmountOfMoney AmountOfMoneyData + {value = Nothing, minValue = Nothing, maxValue = Nothing}) = True +isCurrencyOnly _ = False + +isSimpleAmountOfMoney :: Predicate +isSimpleAmountOfMoney (Token AmountOfMoney AmountOfMoneyData + {minValue = Nothing, maxValue = Nothing}) = True +isSimpleAmountOfMoney _ = False + +isDime :: Predicate +isDime (Token AmountOfMoney AmountOfMoneyData + {value = Just d, currency = Cent}) = + maybe False (\i -> (i `mod` 10) == 0) $ getIntValue d +isDime _ = False + +isCent :: Predicate +isCent (Token AmountOfMoney AmountOfMoneyData + {value = Just c, currency = Cent}) = + maybe False (\i -> i >= 0 && i <= 9) $ getIntValue c +isCent _ = False -- ----------------------------------------------------------------- -- Production diff --git a/Duckling/AmountOfMoney/ID/Corpus.hs b/Duckling/AmountOfMoney/ID/Corpus.hs --- a/Duckling/AmountOfMoney/ID/Corpus.hs +++ b/Duckling/AmountOfMoney/ID/Corpus.hs @@ -21,7 +21,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale ID Nothing}, allExamples) +corpus = (testContext {locale = makeLocale ID Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/AmountOfMoney/ID/Rules.hs b/Duckling/AmountOfMoney/ID/Rules.hs --- a/Duckling/AmountOfMoney/ID/Rules.hs +++ b/Duckling/AmountOfMoney/ID/Rules.hs @@ -7,6 +7,7 @@ {-# LANGUAGE GADTs #-} +{-# LANGUAGE LambdaCase #-} {-# LANGUAGE OverloadedStrings #-} module Duckling.AmountOfMoney.ID.Rules @@ -18,14 +19,28 @@ import Prelude import Duckling.AmountOfMoney.Helpers -import Duckling.AmountOfMoney.Types (Currency(..)) +import Duckling.AmountOfMoney.Types (Currency(..), AmountOfMoneyData(..)) import Duckling.Dimensions.Types -import Duckling.Numeral.Helpers (isNatural) +import Duckling.Numeral.Helpers (isNatural, isPositive) import Duckling.Numeral.Types (NumeralData (..)) import Duckling.Types import qualified Duckling.AmountOfMoney.Types as TAmountOfMoney import qualified Duckling.Numeral.Types as TNumeral +ruleUnitAmount :: Rule +ruleUnitAmount = Rule + { name = " " + , pattern = + [ Predicate isCurrencyOnly + , Predicate isPositive + ] + , prod = \case + (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.currency = c}: + Token Numeral NumeralData{TNumeral.value = v}: + _) -> Just . Token AmountOfMoney . withValue v $ currencyOnly c + _ -> Nothing + } + ruleDollar :: Rule ruleDollar = Rule { name = "$" @@ -78,7 +93,8 @@ rules :: [Rule] rules = - [ ruleDollar + [ ruleUnitAmount + , ruleDollar , ruleIdr , ruleIntersect , ruleJpy diff --git a/Duckling/AmountOfMoney/KO/Corpus.hs b/Duckling/AmountOfMoney/KO/Corpus.hs --- a/Duckling/AmountOfMoney/KO/Corpus.hs +++ b/Duckling/AmountOfMoney/KO/Corpus.hs @@ -21,7 +21,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale KO Nothing}, allExamples) +corpus = (testContext {locale = makeLocale KO Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/AmountOfMoney/KO/Rules.hs b/Duckling/AmountOfMoney/KO/Rules.hs --- a/Duckling/AmountOfMoney/KO/Rules.hs +++ b/Duckling/AmountOfMoney/KO/Rules.hs @@ -7,6 +7,7 @@ {-# LANGUAGE GADTs #-} +{-# LANGUAGE LambdaCase #-} {-# LANGUAGE OverloadedStrings #-} module Duckling.AmountOfMoney.KO.Rules @@ -20,9 +21,26 @@ import Duckling.Dimensions.Types import Duckling.AmountOfMoney.Helpers import Duckling.AmountOfMoney.Types (Currency(..), AmountOfMoneyData (..)) +import Duckling.Numeral.Helpers (isPositive) +import Duckling.Numeral.Types (NumeralData (..)) import Duckling.Types import qualified Duckling.AmountOfMoney.Types as TAmountOfMoney +import qualified Duckling.Numeral.Types as TNumeral +ruleUnitAmount :: Rule +ruleUnitAmount = Rule + { name = " " + , pattern = + [ Predicate isCurrencyOnly + , Predicate isPositive + ] + , prod = \case + (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.currency = c}: + Token Numeral NumeralData{TNumeral.value = v}: + _) -> Just . Token AmountOfMoney . withValue v $ currencyOnly c + _ -> Nothing + } + ruleAmountofmoneyAbout :: Rule ruleAmountofmoneyAbout = Rule { name = " about" @@ -147,7 +165,8 @@ rules :: [Rule] rules = - [ ruleAboutAmountofmoney + [ ruleUnitAmount + , ruleAboutAmountofmoney , ruleAmountofmoneyAbout , ruleAud , ruleCent diff --git a/Duckling/AmountOfMoney/NB/Corpus.hs b/Duckling/AmountOfMoney/NB/Corpus.hs --- a/Duckling/AmountOfMoney/NB/Corpus.hs +++ b/Duckling/AmountOfMoney/NB/Corpus.hs @@ -21,7 +21,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale NB Nothing}, allExamples) +corpus = (testContext {locale = makeLocale NB Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/AmountOfMoney/NB/Rules.hs b/Duckling/AmountOfMoney/NB/Rules.hs --- a/Duckling/AmountOfMoney/NB/Rules.hs +++ b/Duckling/AmountOfMoney/NB/Rules.hs @@ -7,6 +7,7 @@ {-# LANGUAGE GADTs #-} +{-# LANGUAGE LambdaCase #-} {-# LANGUAGE OverloadedStrings #-} module Duckling.AmountOfMoney.NB.Rules @@ -20,12 +21,26 @@ import Duckling.AmountOfMoney.Helpers import Duckling.AmountOfMoney.Types (Currency (..), AmountOfMoneyData (..)) import Duckling.Dimensions.Types -import Duckling.Numeral.Helpers (isNatural) +import Duckling.Numeral.Helpers (isNatural, isPositive) import Duckling.Numeral.Types (NumeralData (..)) import Duckling.Types import qualified Duckling.AmountOfMoney.Types as TAmountOfMoney import qualified Duckling.Numeral.Types as TNumeral +ruleUnitAmount :: Rule +ruleUnitAmount = Rule + { name = " " + , pattern = + [ Predicate isCurrencyOnly + , Predicate isPositive + ] + , prod = \case + (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.currency = c}: + Token Numeral NumeralData{TNumeral.value = v}: + _) -> Just . Token AmountOfMoney . withValue v $ currencyOnly c + _ -> Nothing + } + ruleIntersectAndNumeral :: Rule ruleIntersectAndNumeral = Rule { name = "intersect (and number)" @@ -152,7 +167,8 @@ rules :: [Rule] rules = - [ ruleAboutAmountofmoney + [ ruleUnitAmount + , ruleAboutAmountofmoney , ruleCent , ruleDirham , ruleIntersect diff --git a/Duckling/AmountOfMoney/NL/Corpus.hs b/Duckling/AmountOfMoney/NL/Corpus.hs new file mode 100644 --- /dev/null +++ b/Duckling/AmountOfMoney/NL/Corpus.hs @@ -0,0 +1,106 @@ +-- Copyright (c) 2016-present, Facebook, Inc. +-- All rights reserved. +-- +-- This source code is licensed under the BSD-style license found in the +-- LICENSE file in the root directory of this source tree. An additional grant +-- of patent rights can be found in the PATENTS file in the same directory. + + +{-# LANGUAGE OverloadedStrings #-} + +module Duckling.AmountOfMoney.NL.Corpus + ( corpus + ) where + +import Data.String +import Prelude + +import Duckling.AmountOfMoney.Types +import Duckling.Locale +import Duckling.Resolve +import Duckling.Testing.Types + +corpus :: Corpus +corpus = (testContext {locale = makeLocale NL Nothing}, testOptions, allExamples) + +allExamples :: [Example] +allExamples = concat + [ examples (simple Dollar 1) + [ "$1" + , "1 dollar" + ] + , examples (simple Dollar 10) + [ "$10" + , "$ 10" + , "10$" + , "10 dollars" + , "tien dollar" + ] + , examples (simple Cent 10) + [ "10 cent" + , "tien pennies" + , "tien cents" + , "10 c" + , "10¢" + ] + , examples (simple Dollar 10000) + [ "$10K" + , "10k$" + , "$10000" + , "10000,00 $" + ] + , examples (simple USD 3.14) + [ "USD3,14" + , "3,14US$" + , "US$ 3,14" + ] + , examples (simple EUR 20) + [ "20\x20ac" + , "20 euros" + , "20 Euro" + , "20 Euros" + , "EUR 20" + , "EUR 20,0" + , "20€" + , "20 €ur" + ] + , examples (simple Dollar 20.43) + [ "$20 en 43c" + , "$20,43" + , "20 dollar 43c" + , "20 dollars 43 cents" + , "20 dollar 43" + ] + , examples (simple GBP 3.01) + [ "GBP3,01" + , "GBP 3,01" + , "3 GBP een penny" + ] + , examples (simple Unnamed 42) + [ "42 bucks" + , "ongeveer twee-en-veertig bucks" + , "precies 42 bucks" + ] + , examples (between Dollar (10, 20)) + [ "vanaf 10 dollars tot 20 dollars" + , "rond de 10-20 dollars" + , "tussen 10 dollars en 20 dollars" + , "ongeveer $10-$20" + , "10-20 dollars" + ] + , examples (between Dollar (1.1, 1.3)) + [ "tussen 1,1 dollar en 1,3 dollars" + , "van 1,1$ en 1,3 dollars" + ] + , examples (under EUR 7) + [ "minder dan 7 euros" + , "minder dan zeven EUR" + , "lager dan 7€" + ] + , examples (above Dollar 1.42) + [ "meer dan 1 dollar en 42 cents" + , "minstens $1,42" + , "boven de 1,42 dollars" + , "boven de 1 dollar en 42 cents" + ] + ] diff --git a/Duckling/AmountOfMoney/NL/Rules.hs b/Duckling/AmountOfMoney/NL/Rules.hs new file mode 100644 --- /dev/null +++ b/Duckling/AmountOfMoney/NL/Rules.hs @@ -0,0 +1,270 @@ +-- Copyright (c) 2016-present, Facebook, Inc. +-- All rights reserved. +-- +-- This source code is licensed under the BSD-style license found in the +-- LICENSE file in the root directory of this source tree. An additional grant +-- of patent rights can be found in the PATENTS file in the same directory. + + +{-# LANGUAGE GADTs #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE OverloadedStrings #-} + +module Duckling.AmountOfMoney.NL.Rules + ( rules + ) where + +import Data.Maybe +import Data.String +import Prelude +import qualified Data.Text as Text + +import Duckling.AmountOfMoney.Helpers +import Duckling.AmountOfMoney.Types (Currency(..), AmountOfMoneyData (..)) +import Duckling.Dimensions.Types +import Duckling.Numeral.Helpers (isNatural, isPositive) +import Duckling.Numeral.Types (NumeralData (..)) +import Duckling.Regex.Types +import Duckling.Types +import qualified Duckling.AmountOfMoney.Types as TAmountOfMoney +import qualified Duckling.Numeral.Types as TNumeral + +ruleUnitAmount :: Rule +ruleUnitAmount = Rule + { name = " " + , pattern = + [ Predicate isCurrencyOnly + , Predicate isPositive + ] + , prod = \case + (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.currency = c}: + Token Numeral NumeralData{TNumeral.value = v}: + _) -> Just . Token AmountOfMoney . withValue v $ currencyOnly c + _ -> Nothing + } + +rulePounds :: Rule +rulePounds = Rule + { name = "£" + , pattern = + [ regex "pou?nds?" + ] + , prod = \_ -> Just . Token AmountOfMoney $ currencyOnly Pound + } + +ruleCent :: Rule +ruleCent = Rule + { name = "cent" + , pattern = + [ regex "cents?|penn(y|ies)|pence|sens?" + ] + , prod = \_ -> Just . Token AmountOfMoney $ currencyOnly Cent + } + +ruleBucks :: Rule +ruleBucks = Rule + { name = "bucks" + , pattern = + [ regex "bucks?" + ] + , prod = \_ -> Just . Token AmountOfMoney $ currencyOnly Unnamed + } + +ruleIntersectAndXCents :: Rule +ruleIntersectAndXCents = Rule + { name = "intersect (and X cents)" + , pattern = + [ Predicate isWithoutCents + , regex "en" + , Predicate isCents + ] + , prod = \tokens -> case tokens of + (Token AmountOfMoney fd: + _: + Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just c}: + _) -> Just . Token AmountOfMoney $ withCents c fd + _ -> Nothing + } + +ruleIntersect :: Rule +ruleIntersect = Rule + { name = "intersect" + , pattern = + [ Predicate isWithoutCents + , Predicate isNatural + ] + , prod = \tokens -> case tokens of + (Token AmountOfMoney fd: + Token Numeral NumeralData{TNumeral.value = c}: + _) -> Just . Token AmountOfMoney $ withCents c fd + _ -> Nothing + } + +ruleIntersectAndNumeral :: Rule +ruleIntersectAndNumeral = Rule + { name = "intersect (and number)" + , pattern = + [ Predicate isWithoutCents + , regex "en" + , Predicate isNatural + ] + , prod = \tokens -> case tokens of + (Token AmountOfMoney fd: + _: + Token Numeral NumeralData{TNumeral.value = c}: + _) -> Just . Token AmountOfMoney $ withCents c fd + _ -> Nothing + } + +ruleIntersectXCents :: Rule +ruleIntersectXCents = Rule + { name = "intersect (X cents)" + , pattern = + [ Predicate isWithoutCents + , Predicate isCents + ] + , prod = \tokens -> case tokens of + (Token AmountOfMoney fd: + Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just c}: + _) -> Just . Token AmountOfMoney $ withCents c fd + _ -> Nothing + } + +rulePrecision :: Rule +rulePrecision = Rule + { name = "about|exactly " + , pattern = + [ regex "precies|ongeveer|over|dicht|bijna|in de buurt|rond de" + , Predicate isMoneyWithValue + ] + , prod = \tokens -> case tokens of + (_:token:_) -> Just token + _ -> Nothing + } + +ruleIntervalBetweenNumeral :: Rule +ruleIntervalBetweenNumeral = Rule + { name = "between|from to|and " + , pattern = + [ regex "tussen|vanaf|van" + , Predicate isPositive + , regex "tot|en" + , financeWith TAmountOfMoney.value isJust + ] + , prod = \tokens -> case tokens of + (_: + Token Numeral NumeralData{TNumeral.value = from}: + _: + Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to, + TAmountOfMoney.currency = c}: + _) | from < to -> + Just . Token AmountOfMoney . withInterval (from, to) $ currencyOnly c + _ -> Nothing + } + +ruleIntervalBetween :: Rule +ruleIntervalBetween = Rule + { name = "between|from to|and " + , pattern = + [ regex "tussen|vanaf|van" + , financeWith TAmountOfMoney.value isJust + , regex "tot|en" + , financeWith TAmountOfMoney.value isJust + ] + , prod = \tokens -> case tokens of + (_: + Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just from, + TAmountOfMoney.currency = c1}: + _: + Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to, + TAmountOfMoney.currency = c2}: + _) | from < to && c1 == c2 -> + Just . Token AmountOfMoney . withInterval (from, to) $ currencyOnly c1 + _ -> Nothing + } + +ruleIntervalNumeralDash :: Rule +ruleIntervalNumeralDash = Rule + { name = " - " + , pattern = + [ Predicate isNatural + , regex "\\-" + , financeWith TAmountOfMoney.value isJust + ] + , prod = \tokens -> case tokens of + (Token Numeral NumeralData{TNumeral.value = from}: + _: + Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to, + TAmountOfMoney.currency = c}: + _) | from < to -> + Just . Token AmountOfMoney . withInterval (from, to) $ currencyOnly c + _ -> Nothing + } + +ruleIntervalDash :: Rule +ruleIntervalDash = Rule + { name = " - " + , pattern = + [ financeWith TAmountOfMoney.value isJust + , regex "\\-" + , financeWith TAmountOfMoney.value isJust + ] + , prod = \tokens -> case tokens of + (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just from, + TAmountOfMoney.currency = c1}: + _: + Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to, + TAmountOfMoney.currency = c2}: + _) | from < to && c1 == c2 -> + Just . Token AmountOfMoney . withInterval (from, to) $ currencyOnly c1 + _ -> Nothing + } + +ruleIntervalMax :: Rule +ruleIntervalMax = Rule + { name = "under/less/lower/no more than " + , pattern = + [ regex "(minder|lager|niet? meer) dan" + , financeWith TAmountOfMoney.value isJust + ] + , prod = \tokens -> case tokens of + (_: + Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to, + TAmountOfMoney.currency = c}: + _) -> Just . Token AmountOfMoney . withMax to $ currencyOnly c + _ -> Nothing + } + +ruleIntervalMin :: Rule +ruleIntervalMin = Rule + { name = "over/above/at least/more than " + , pattern = + [ regex "boven de|minstens|meer dan" + , financeWith TAmountOfMoney.value isJust + ] + , prod = \tokens -> case tokens of + (_: + Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to, + TAmountOfMoney.currency = c}: + _) -> Just . Token AmountOfMoney . withMin to $ currencyOnly c + _ -> Nothing + } + +rules :: [Rule] +rules = + [ ruleUnitAmount + , ruleBucks + , ruleCent + , ruleIntersect + , ruleIntersectAndNumeral + , ruleIntersectAndXCents + , ruleIntersectXCents + , ruleIntervalBetweenNumeral + , ruleIntervalBetween + , ruleIntervalMax + , ruleIntervalMin + , ruleIntervalNumeralDash + , ruleIntervalDash + , rulePounds + , rulePrecision + ] diff --git a/Duckling/AmountOfMoney/PT/Corpus.hs b/Duckling/AmountOfMoney/PT/Corpus.hs --- a/Duckling/AmountOfMoney/PT/Corpus.hs +++ b/Duckling/AmountOfMoney/PT/Corpus.hs @@ -21,7 +21,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale PT Nothing}, allExamples) +corpus = (testContext {locale = makeLocale PT Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/AmountOfMoney/PT/Rules.hs b/Duckling/AmountOfMoney/PT/Rules.hs --- a/Duckling/AmountOfMoney/PT/Rules.hs +++ b/Duckling/AmountOfMoney/PT/Rules.hs @@ -7,6 +7,7 @@ {-# LANGUAGE GADTs #-} +{-# LANGUAGE LambdaCase #-} {-# LANGUAGE OverloadedStrings #-} module Duckling.AmountOfMoney.PT.Rules @@ -20,12 +21,26 @@ import Duckling.AmountOfMoney.Helpers import Duckling.AmountOfMoney.Types (Currency(..), AmountOfMoneyData (..)) import Duckling.Dimensions.Types -import Duckling.Numeral.Helpers (isNatural) +import Duckling.Numeral.Helpers (isNatural, isPositive) import Duckling.Numeral.Types (NumeralData (..)) import Duckling.Types import qualified Duckling.AmountOfMoney.Types as TAmountOfMoney import qualified Duckling.Numeral.Types as TNumeral +ruleUnitAmount :: Rule +ruleUnitAmount = Rule + { name = " " + , pattern = + [ Predicate isCurrencyOnly + , Predicate isPositive + ] + , prod = \case + (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.currency = c}: + Token Numeral NumeralData{TNumeral.value = v}: + _) -> Just . Token AmountOfMoney . withValue v $ currencyOnly c + _ -> Nothing + } + ruleIntersectAndNumeral :: Rule ruleIntersectAndNumeral = Rule { name = "intersect (and number)" @@ -124,7 +139,8 @@ rules :: [Rule] rules = - [ ruleBrl + [ ruleUnitAmount + , ruleBrl , ruleCent , ruleDollar , ruleIntersect diff --git a/Duckling/AmountOfMoney/RO/Corpus.hs b/Duckling/AmountOfMoney/RO/Corpus.hs --- a/Duckling/AmountOfMoney/RO/Corpus.hs +++ b/Duckling/AmountOfMoney/RO/Corpus.hs @@ -21,7 +21,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale RO Nothing}, allExamples) +corpus = (testContext {locale = makeLocale RO Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/AmountOfMoney/RO/Rules.hs b/Duckling/AmountOfMoney/RO/Rules.hs --- a/Duckling/AmountOfMoney/RO/Rules.hs +++ b/Duckling/AmountOfMoney/RO/Rules.hs @@ -7,6 +7,7 @@ {-# LANGUAGE GADTs #-} +{-# LANGUAGE LambdaCase #-} {-# LANGUAGE OverloadedStrings #-} module Duckling.AmountOfMoney.RO.Rules @@ -21,13 +22,27 @@ import Duckling.AmountOfMoney.Helpers import Duckling.AmountOfMoney.Types (Currency(..), AmountOfMoneyData (..)) import Duckling.Dimensions.Types -import Duckling.Numeral.Helpers (isNatural) +import Duckling.Numeral.Helpers (isNatural, isPositive) import Duckling.Numeral.Types (NumeralData (..)) import Duckling.Regex.Types import Duckling.Types import qualified Duckling.AmountOfMoney.Types as TAmountOfMoney import qualified Duckling.Numeral.Types as TNumeral +ruleUnitAmount :: Rule +ruleUnitAmount = Rule + { name = " " + , pattern = + [ Predicate isCurrencyOnly + , Predicate isPositive + ] + , prod = \case + (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.currency = c}: + Token Numeral NumeralData{TNumeral.value = v}: + _) -> Just . Token AmountOfMoney . withValue v $ currencyOnly c + _ -> Nothing + } + ruleIntersectAndNumeral :: Rule ruleIntersectAndNumeral = Rule { name = "intersect (and number)" @@ -195,7 +210,8 @@ rules :: [Rule] rules = - [ ruleAed + [ ruleUnitAmount + , ruleAed , ruleCent , ruleDollar , ruleInr diff --git a/Duckling/AmountOfMoney/RU/Corpus.hs b/Duckling/AmountOfMoney/RU/Corpus.hs --- a/Duckling/AmountOfMoney/RU/Corpus.hs +++ b/Duckling/AmountOfMoney/RU/Corpus.hs @@ -21,7 +21,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale RU Nothing}, allExamples) +corpus = (testContext {locale = makeLocale RU Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/AmountOfMoney/RU/Rules.hs b/Duckling/AmountOfMoney/RU/Rules.hs --- a/Duckling/AmountOfMoney/RU/Rules.hs +++ b/Duckling/AmountOfMoney/RU/Rules.hs @@ -7,6 +7,7 @@ {-# LANGUAGE GADTs #-} +{-# LANGUAGE LambdaCase #-} {-# LANGUAGE OverloadedStrings #-} module Duckling.AmountOfMoney.RU.Rules @@ -28,6 +29,20 @@ import qualified Duckling.AmountOfMoney.Types as TAmountOfMoney import qualified Duckling.Numeral.Types as TNumeral +ruleUnitAmount :: Rule +ruleUnitAmount = Rule + { name = " " + , pattern = + [ Predicate isCurrencyOnly + , Predicate isPositive + ] + , prod = \case + (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.currency = c}: + Token Numeral NumeralData{TNumeral.value = v}: + _) -> Just . Token AmountOfMoney . withValue v $ currencyOnly c + _ -> Nothing + } + ruleRuble :: Rule ruleRuble = Rule { name = "руб" @@ -284,7 +299,8 @@ rules :: [Rule] rules = - [ ruleBucks + [ ruleUnitAmount + , ruleBucks , ruleCent , ruleDollar , ruleEUR diff --git a/Duckling/AmountOfMoney/Rules.hs b/Duckling/AmountOfMoney/Rules.hs --- a/Duckling/AmountOfMoney/Rules.hs +++ b/Duckling/AmountOfMoney/Rules.hs @@ -40,6 +40,9 @@ , ("byn", BYN) , ("¢", Cent) , ("c", Cent) + , ("cny", CNY) + , ("rmb", CNY) + , ("yuan", CNY) , ("$", Dollar) , ("dinar", Dinar) , ("dinars", Dinar) @@ -103,7 +106,7 @@ ruleCurrencies = Rule { name = "currencies" , pattern = - [ regex "(aed|aud|bgn|brl|byn|¢|c|\\$|dinars?|dollars?|egp|(e|€)uro?s?|€|gbp|hrk|idr|ils|inr|iqd|jod|¥|jpy|krw|kwd|lbp|mad|myr|rm|nok|£|pta?s?|qar|₽|rs\\.?|riy?als?|ron|rub|rupees?|sar|sek|sgb|shekels?|us(d|\\$)|vnd|yen)" + [ regex "(aed|aud|bgn|brl|byn|¢|c|cny|\\$|dinars?|dollars?|egp|(e|€)uro?s?|€|gbp|hrk|idr|ils|inr|iqd|jod|¥|jpy|krw|kwd|lbp|mad|myr|rm|nok|£|pta?s?|qar|₽|rs\\.?|riy?als?|ron|rub|rupees?|sar|sek|sgb|shekels?|us(d|\\$)|vnd|yen|yuan)" ] , prod = \tokens -> case tokens of (Token RegexMatch (GroupMatch (match:_)):_) -> do @@ -117,7 +120,7 @@ { name = " " , pattern = [ Predicate isPositive - , financeWith TAmountOfMoney.value isNothing + , Predicate isCurrencyOnly ] , prod = \tokens -> case tokens of (Token Numeral NumeralData{TNumeral.value = v}: @@ -126,23 +129,8 @@ _ -> Nothing } -ruleUnitAmount :: Rule -ruleUnitAmount = Rule - { name = " " - , pattern = - [ financeWith TAmountOfMoney.value isNothing - , Predicate isPositive - ] - , prod = \tokens -> case tokens of - (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.currency = c}: - Token Numeral NumeralData{TNumeral.value = v}: - _) -> Just . Token AmountOfMoney . withValue v $ currencyOnly c - _ -> Nothing - } - rules :: [Rule] rules = [ ruleAmountUnit , ruleCurrencies - , ruleUnitAmount ] diff --git a/Duckling/AmountOfMoney/SV/Corpus.hs b/Duckling/AmountOfMoney/SV/Corpus.hs --- a/Duckling/AmountOfMoney/SV/Corpus.hs +++ b/Duckling/AmountOfMoney/SV/Corpus.hs @@ -21,7 +21,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale SV Nothing}, allExamples) +corpus = (testContext {locale = makeLocale SV Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/AmountOfMoney/SV/Rules.hs b/Duckling/AmountOfMoney/SV/Rules.hs --- a/Duckling/AmountOfMoney/SV/Rules.hs +++ b/Duckling/AmountOfMoney/SV/Rules.hs @@ -7,6 +7,7 @@ {-# LANGUAGE GADTs #-} +{-# LANGUAGE LambdaCase #-} {-# LANGUAGE OverloadedStrings #-} module Duckling.AmountOfMoney.SV.Rules @@ -20,12 +21,26 @@ import Duckling.AmountOfMoney.Helpers import Duckling.AmountOfMoney.Types (Currency(..), AmountOfMoneyData (..)) import Duckling.Dimensions.Types -import Duckling.Numeral.Helpers (isNatural) +import Duckling.Numeral.Helpers (isNatural, isPositive) import Duckling.Numeral.Types (NumeralData (..)) import Duckling.Types import qualified Duckling.AmountOfMoney.Types as TAmountOfMoney import qualified Duckling.Numeral.Types as TNumeral +ruleUnitAmount :: Rule +ruleUnitAmount = Rule + { name = " " + , pattern = + [ Predicate isCurrencyOnly + , Predicate isPositive + ] + , prod = \case + (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.currency = c}: + Token Numeral NumeralData{TNumeral.value = v}: + _) -> Just . Token AmountOfMoney . withValue v $ currencyOnly c + _ -> Nothing + } + ruleIntersectAndNumeral :: Rule ruleIntersectAndNumeral = Rule { name = "intersect (and number)" @@ -157,7 +172,8 @@ rules :: [Rule] rules = - [ ruleAboutAmountofmoney + [ ruleUnitAmount + , ruleAboutAmountofmoney , ruleCent , ruleDirham , ruleExactlyAmountofmoney diff --git a/Duckling/AmountOfMoney/Types.hs b/Duckling/AmountOfMoney/Types.hs --- a/Duckling/AmountOfMoney/Types.hs +++ b/Duckling/AmountOfMoney/Types.hs @@ -41,6 +41,7 @@ | BGN | BRL | BYN + | CNY | EGP | EUR | GBP @@ -82,6 +83,7 @@ toJSON BGN = "BGN" toJSON BRL = "BRL" toJSON BYN = "BYN" + toJSON CNY = "CNY" toJSON EGP = "EGP" toJSON EUR = "EUR" toJSON GBP = "GBP" @@ -118,19 +120,19 @@ instance Resolve AmountOfMoneyData where type ResolvedValue AmountOfMoneyData = AmountOfMoneyValue - resolve _ AmountOfMoneyData {value = Nothing, minValue = Nothing + resolve _ _ AmountOfMoneyData {value = Nothing, minValue = Nothing , maxValue = Nothing} = Nothing - resolve _ AmountOfMoneyData {value = Just value, currency} = - Just $ simple currency value - resolve _ AmountOfMoneyData {value = Nothing, currency = c + resolve _ _ AmountOfMoneyData {value = Just value, currency} = + Just (simple currency value, False) + resolve _ _ AmountOfMoneyData {value = Nothing, currency = c , minValue = Just from, maxValue = Just to} = - Just $ between c (from, to) - resolve _ AmountOfMoneyData {value = Nothing, currency = c + Just (between c (from, to), False) + resolve _ _ AmountOfMoneyData {value = Nothing, currency = c , minValue = Just v, maxValue = Nothing} = - Just $ above c v - resolve _ AmountOfMoneyData {value = Nothing, currency = c + Just (above c v, False) + resolve _ _ AmountOfMoneyData {value = Nothing, currency = c , minValue = Nothing, maxValue = Just v} = - Just $ under c v + Just (under c v, False) data IntervalDirection = Above | Under deriving (Eq, Generic, Hashable, Ord, Show, NFData) diff --git a/Duckling/AmountOfMoney/VI/Corpus.hs b/Duckling/AmountOfMoney/VI/Corpus.hs --- a/Duckling/AmountOfMoney/VI/Corpus.hs +++ b/Duckling/AmountOfMoney/VI/Corpus.hs @@ -21,7 +21,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale VI Nothing}, allExamples) +corpus = (testContext {locale = makeLocale VI Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat @@ -37,12 +37,12 @@ , "mười xu" ] , examples (simple Dollar 10000) - [ "$10,000" + [ "$10.000" , "10K$" , "$10k" ] , examples (simple USD 1.23) - [ "USD1.23" + [ "USD1,23" ] , examples (simple Dollar 2.23) [ "2 đô la và 23 xen" @@ -56,7 +56,7 @@ [ "mười đồng" ] , examples (simple VND 10000) - [ "10,000 đồng" + [ "10.000 đồng" , "10K đồng" , "10k đồng" ] @@ -72,7 +72,7 @@ , "EUR 20" ] , examples (simple EUR 29.99) - [ "EUR29.99" + [ "EUR29,99" ] , examples (simple INR 20) [ "Rs. 20" @@ -94,8 +94,8 @@ , "chín pounds" ] , examples (simple GBP 3.01) - [ "GBP3.01" - , "GBP 3.01" + [ "GBP3,01" + , "GBP 3,01" ] , examples (simple AED 1) [ "1 AED." diff --git a/Duckling/AmountOfMoney/VI/Rules.hs b/Duckling/AmountOfMoney/VI/Rules.hs --- a/Duckling/AmountOfMoney/VI/Rules.hs +++ b/Duckling/AmountOfMoney/VI/Rules.hs @@ -7,6 +7,7 @@ {-# LANGUAGE GADTs #-} +{-# LANGUAGE LambdaCase #-} {-# LANGUAGE OverloadedStrings #-} module Duckling.AmountOfMoney.VI.Rules @@ -20,12 +21,26 @@ import Duckling.AmountOfMoney.Helpers import Duckling.AmountOfMoney.Types (Currency(..), AmountOfMoneyData (..)) import Duckling.Dimensions.Types -import Duckling.Numeral.Helpers (isNatural) +import Duckling.Numeral.Helpers (isNatural, isPositive) import Duckling.Numeral.Types (NumeralData (..)) import Duckling.Types import qualified Duckling.AmountOfMoney.Types as TAmountOfMoney import qualified Duckling.Numeral.Types as TNumeral +ruleUnitAmount :: Rule +ruleUnitAmount = Rule + { name = " " + , pattern = + [ Predicate isCurrencyOnly + , Predicate isPositive + ] + , prod = \case + (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.currency = c}: + Token Numeral NumeralData{TNumeral.value = v}: + _) -> Just . Token AmountOfMoney . withValue v $ currencyOnly c + _ -> Nothing + } + ruleNg :: Rule ruleNg = Rule { name = "đồng" @@ -142,7 +157,8 @@ rules :: [Rule] rules = - [ ruleCent + [ ruleUnitAmount + , ruleCent , ruleDirham , ruleDollar , ruleIntersect diff --git a/Duckling/AmountOfMoney/ZH/Corpus.hs b/Duckling/AmountOfMoney/ZH/Corpus.hs new file mode 100644 --- /dev/null +++ b/Duckling/AmountOfMoney/ZH/Corpus.hs @@ -0,0 +1,68 @@ +-- Copyright (c) 2016-present, Facebook, Inc. +-- All rights reserved. +-- +-- This source code is licensed under the BSD-style license found in the +-- LICENSE file in the root directory of this source tree. An additional grant +-- of patent rights can be found in the PATENTS file in the same directory. + + +{-# LANGUAGE OverloadedStrings #-} + +module Duckling.AmountOfMoney.ZH.Corpus + ( corpus + ) where + +import Data.String +import Prelude + +import Duckling.AmountOfMoney.Types +import Duckling.Locale +import Duckling.Resolve +import Duckling.Testing.Types + +corpus :: Corpus +corpus = (testContext {locale = makeLocale ZH Nothing}, + testOptions, allExamples) + +allExamples :: [Example] +allExamples = concat + [ examples (simple Cent 5) + [ "五分" + , "5分" + ] + , examples (simple Cent 20) + [ "20分" + , "二十分" + , "2角" + , "两毛" + ] + , examples (simple Cent 25) + [ "25分" + , "二十五分" + , "两角五分" + , "两毛五" + ] + , examples (simple Dollar 7) + [ "7块" + , "七元" + ] + , examples (simple CNY 3.14) + [ "3.14人民币" + , "人民幣3.14" + ] + , examples (under Dollar 1.2) + [ "1.2元以下" + , "最多一块二角" + , "最多一块二" + ] + , examples (above Dollar 3.04) + [ "3.04块以上" + , "至少三块四分" + , "至少三块零四" + ] + , examples (between Dollar (5.6, 5.78)) + [ "5.6到5.78元" + , "五元六角-五元七毛八分" + , "五块六到五块七毛八" + ] + ] diff --git a/Duckling/AmountOfMoney/ZH/Rules.hs b/Duckling/AmountOfMoney/ZH/Rules.hs new file mode 100644 --- /dev/null +++ b/Duckling/AmountOfMoney/ZH/Rules.hs @@ -0,0 +1,274 @@ +-- Copyright (c) 2016-present, Facebook, Inc. +-- All rights reserved. +-- +-- This source code is licensed under the BSD-style license found in the +-- LICENSE file in the root directory of this source tree. An additional grant +-- of patent rights can be found in the PATENTS file in the same directory. + + +{-# LANGUAGE GADTs #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE OverloadedStrings #-} + +module Duckling.AmountOfMoney.ZH.Rules + ( rules + ) where + +import Data.Maybe +import Data.String +import Prelude +import qualified Data.Text as Text + +import Duckling.AmountOfMoney.Helpers +import Duckling.AmountOfMoney.Types (Currency (..), AmountOfMoneyData (..)) +import Duckling.Dimensions.Types +import Duckling.Numeral.Helpers (isNatural, isPositive, oneOf) +import Duckling.Numeral.Types (NumeralData (..)) +import Duckling.Regex.Types +import Duckling.Types +import qualified Duckling.AmountOfMoney.Types as TAmountOfMoney +import qualified Duckling.Numeral.Types as TNumeral + +ruleCNY :: Rule +ruleCNY = Rule + { name = "cny" + , pattern = + [ regex "人民币|人民幣" + ] + , prod = \_ -> Just . Token AmountOfMoney $ currencyOnly CNY + } + +ruleCNYPrefix :: Rule +ruleCNYPrefix = Rule + { name = "cny prefix" + , pattern = + [ regex "人民币|人民幣" + , Predicate isPositive + ] + , prod = \case + (_:Token Numeral NumeralData{TNumeral.value = v}:_) -> + Just . Token AmountOfMoney . withValue v $ currencyOnly CNY + _ -> Nothing + } + +ruleCent :: Rule +ruleCent = Rule + { name = "cent" + , pattern = + [ regex "分" + ] + , prod = \_ -> Just . Token AmountOfMoney $ currencyOnly Cent +} + +ruleDime :: Rule +ruleDime = Rule + { name = "dime" + , pattern = + [ Predicate isPositive + , regex "角|毛" + ] + , prod = \case + (Token Numeral NumeralData{TNumeral.value = v}:_) -> + Just . Token AmountOfMoney $ + withCents (v * 10) $ currencyOnly Cent + _ -> Nothing + } + +ruleDollar :: Rule +ruleDollar = Rule + { name = "dollar" + , pattern = + [ regex "元|圆|块" + ] + , prod = \_ -> Just . Token AmountOfMoney $ currencyOnly Dollar + } + +rulePrecision :: Rule +rulePrecision = Rule + { name = "exactly/about " + , pattern = + [ regex "刚好|恰好|大概" + , Predicate isMoneyWithValue + ] + , prod = \case + (_:token:_) -> Just token + _ -> Nothing + } + +rulePrecision2 :: Rule +rulePrecision2 = Rule + { name = "about " + , pattern = + [ Predicate isMoneyWithValue + , regex "左右" + ] + , prod = \case + (token:_) -> Just token + _ -> Nothing + } + +ruleIntersectDimesAndCents :: Rule +ruleIntersectDimesAndCents = Rule + { name = "intersect (X dimes and X cents)" + , pattern = + [ Predicate $ and . sequence [isSimpleAmountOfMoney, isDime] + , Predicate $ and . sequence [isSimpleAmountOfMoney, isCent] + ] + , prod = \case + (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just d}: + Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just c}: + _) -> + Just . Token AmountOfMoney $ withCents (c + d) $ currencyOnly Cent + _ -> Nothing + } + +ruleIntersectDollarsAndDimesCents :: Rule +ruleIntersectDollarsAndDimesCents = Rule + { name = "intersect (X dollars and X dimes/cents)" + , pattern = + [ Predicate $ and . sequence [isSimpleAmountOfMoney, isWithoutCents] + , Predicate $ and . sequence [isSimpleAmountOfMoney, isCents] + ] + , prod = \case + (Token AmountOfMoney fd: + Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just c}: + _) -> Just . Token AmountOfMoney $ withCents c fd + _ -> Nothing + } + +ruleIntersect :: Rule +ruleIntersect = Rule + { name = "intersect (implicit 0 delimited cents)" + , pattern = + [ Predicate $ and . sequence [isSimpleAmountOfMoney, isWithoutCents] + , regex "0|零|〇" + , oneOf [1..9] + ] + , prod = \case + (Token AmountOfMoney fd:_: + Token Numeral NumeralData{TNumeral.value = c}: + _) -> Just . Token AmountOfMoney $ withCents c fd + _ -> Nothing + } + +ruleIntersect2 :: Rule +ruleIntersect2 = Rule + { name = "intersect (implicit unitless cents)" + , pattern = + [ Predicate $ and . sequence [isSimpleAmountOfMoney, isDime] + , Predicate isNatural + ] + , prod = \case + (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just v}: + Token Numeral NumeralData{TNumeral.value = c}: + _) -> Just . Token AmountOfMoney $ withCents (v + c) $ currencyOnly Cent + _ -> Nothing + } + +ruleIntersect3 :: Rule +ruleIntersect3 = Rule + { name = "intersect (implicit unitless dimes)" + , pattern = + [ Predicate $ and . sequence [isSimpleAmountOfMoney, isWithoutCents] + , Predicate isNatural + ] + , prod = \case + (Token AmountOfMoney fd: + Token Numeral NumeralData{TNumeral.value = d}: + _) -> Just . Token AmountOfMoney $ withCents (d * 10) fd + _ -> Nothing + } + +ruleIntervalNumeralDash :: Rule +ruleIntervalNumeralDash = Rule + { name = " - " + , pattern = + [ Predicate isPositive + , regex "-|~|到" + , financeWith TAmountOfMoney.value isJust + ] + , prod = \case + (Token Numeral NumeralData{TNumeral.value = from}: + _: + Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to, + TAmountOfMoney.currency = c}: + _) | from < to -> + Just . Token AmountOfMoney . withInterval (from, to) $ currencyOnly c + _ -> Nothing + } + +ruleIntervalDash :: Rule +ruleIntervalDash = Rule + { name = " - " + , pattern = + [ financeWith TAmountOfMoney.value isJust + , regex "-|~|到" + , financeWith TAmountOfMoney.value isJust + ] + , prod = \case + (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just from, + TAmountOfMoney.currency = c1}: + _: + Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to, + TAmountOfMoney.currency = c2}: + _) | from < to && c1 == c2 -> + Just . Token AmountOfMoney . withInterval (from, to) $ currencyOnly c1 + _ -> Nothing + } + +ruleIntervalBound :: Rule +ruleIntervalBound = Rule + { name = "under/less/lower/no more than (最多|至少|最少)" + , pattern = + [ regex "(最多|至少|最少)" + , financeWith TAmountOfMoney.value isJust + ] + , prod = \case + (Token RegexMatch (GroupMatch (match:_)): + Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to, + TAmountOfMoney.currency = c}: + _) -> case match of + "最多" -> Just . Token AmountOfMoney . withMax to $ currencyOnly c + "最少" -> Just . Token AmountOfMoney . withMin to $ currencyOnly c + "至少" -> Just . Token AmountOfMoney . withMin to $ currencyOnly c + _ -> Nothing + _ -> Nothing + } + +ruleIntervalBound2 :: Rule +ruleIntervalBound2 = Rule + { name = "under/less/lower/no more than (以下|以上)" + , pattern = + [ financeWith TAmountOfMoney.value isJust + , regex "(以下|以上)" + ] + , prod = \case + (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to, + TAmountOfMoney.currency = c}: + Token RegexMatch (GroupMatch (match:_)): + _) -> case match of + "以下" -> Just . Token AmountOfMoney . withMax to $ currencyOnly c + "以上" -> Just . Token AmountOfMoney . withMin to $ currencyOnly c + _ -> Nothing + _ -> Nothing + } + +rules :: [Rule] +rules = + [ ruleCent + , ruleCNY + , ruleCNYPrefix + , ruleDime + , ruleDollar + , ruleIntersect + , ruleIntersect2 + , ruleIntersect3 + , ruleIntersectDimesAndCents + , ruleIntersectDollarsAndDimesCents + , ruleIntervalDash + , ruleIntervalNumeralDash + , ruleIntervalBound + , ruleIntervalBound2 + , rulePrecision + , rulePrecision2 + ] diff --git a/Duckling/Api.hs b/Duckling/Api.hs --- a/Duckling/Api.hs +++ b/Duckling/Api.hs @@ -21,7 +21,6 @@ import Data.HashSet (HashSet) import Data.Text (Text) import Prelude -import TextShow import qualified Data.HashMap.Strict as HashMap import qualified Data.HashSet as HashSet import qualified Data.Text as Text @@ -37,8 +36,9 @@ import Duckling.Types -- | Parses `input` and returns a curated list of entities found. -parse :: Text -> Context -> [Some Dimension] -> [Entity] -parse input ctx = map (formatToken input) . analyze input ctx . HashSet.fromList +parse :: Text -> Context -> Options -> [Some Dimension] -> [Entity] +parse input ctx options = map (formatToken input) . analyze input ctx options . + HashSet.fromList supportedDimensions :: HashMap Lang [Some Dimension] supportedDimensions = @@ -46,18 +46,19 @@ -- | Returns a curated list of resolved tokens found -- When `targets` is non-empty, returns only tokens of such dimensions. -analyze :: Text -> Context -> HashSet (Some Dimension) -> [ResolvedToken] -analyze input context@Context{..} targets = +analyze :: Text -> Context -> Options -> HashSet (Some Dimension) + -> [ResolvedToken] +analyze input context@Context{..} options targets = rank (classifiers locale) targets . filter (\Resolved{node = Node{token = (Token d _)}} -> HashSet.null targets || HashSet.member (This d) targets ) - $ parseAndResolve (rulesFor locale targets) input context + $ parseAndResolve (rulesFor locale targets) input context options -- | Converts the resolved token to the API format formatToken :: Text -> ResolvedToken -> Entity formatToken sentence - (Resolved (Range start end) node@Node{token = Token dimension _} value) = - Entity (toName dimension) body value start end node + (Resolved (Range start end) node@Node{token = Token dimension _} value latent) + = Entity (toName dimension) body value start end latent node where body = Text.drop start $ Text.take end sentence diff --git a/Duckling/Core.hs b/Duckling/Core.hs --- a/Duckling/Core.hs +++ b/Duckling/Core.hs @@ -12,13 +12,14 @@ module Duckling.Core ( Context(..) - , Region(..) , Dimension(..) , Entity(..) - , Node(..) - , Range(..) , Lang(..) , Locale + , Node(..) + , Options(..) + , Range(..) + , Region(..) , Some(..) , fromName , makeLocale @@ -36,7 +37,6 @@ ) where import Data.HashMap.Strict (HashMap) -import Data.Maybe import Data.Text (Text) import Data.Time import Data.Time.LocalTime.TimeZone.Series diff --git a/Duckling/Debug.hs b/Duckling/Debug.hs --- a/Duckling/Debug.hs +++ b/Duckling/Debug.hs @@ -13,7 +13,7 @@ module Duckling.Debug ( allParses , debug - , debugContext + , debugCustom , fullParses , ptree ) where @@ -38,7 +38,7 @@ -- API debug :: Locale -> Text -> [Some Dimension] -> IO [Entity] -debug locale = debugContext testContext {locale = locale} +debug locale = debugCustom testContext {locale = locale} testOptions allParses :: Locale -> Text -> [Some Dimension] -> IO [Entity] allParses l sentence targets = debugTokens sentence $ parses l sentence targets @@ -50,8 +50,13 @@ where n = Text.length sentence +debugCustom :: Context -> Options -> Text -> [Some Dimension] -> IO [Entity] +debugCustom context options sentence targets = debugTokens sentence . + analyze sentence context options $ HashSet.fromList targets + ptree :: Text -> Entity -> IO () ptree sentence Entity {enode} = pnode sentence 0 enode + -- ----------------------------------------------------------------- -- Internals @@ -62,12 +67,8 @@ [] -> True _ -> elem (This d) targets where - tokens = parseAndResolve rules sentence testContext {locale = l} + tokens = parseAndResolve rules sentence testContext {locale = l} testOptions rules = rulesFor l $ HashSet.fromList targets - -debugContext :: Context -> Text -> [Some Dimension] -> IO [Entity] -debugContext context sentence targets = - debugTokens sentence . analyze sentence context $ HashSet.fromList targets debugTokens :: Text -> [ResolvedToken] -> IO [Entity] debugTokens sentence tokens = do diff --git a/Duckling/Dimensions.hs b/Duckling/Dimensions.hs --- a/Duckling/Dimensions.hs +++ b/Duckling/Dimensions.hs @@ -19,6 +19,8 @@ import qualified Data.HashSet as HashSet import Duckling.Dimensions.Types +import Duckling.Locale +import Duckling.Types import qualified Duckling.Dimensions.Common as CommonDimensions import qualified Duckling.Dimensions.AR as ARDimensions import qualified Duckling.Dimensions.BG as BGDimensions @@ -49,11 +51,11 @@ import qualified Duckling.Dimensions.RO as RODimensions import qualified Duckling.Dimensions.RU as RUDimensions import qualified Duckling.Dimensions.SV as SVDimensions +import qualified Duckling.Dimensions.TA as TADimensions import qualified Duckling.Dimensions.TR as TRDimensions import qualified Duckling.Dimensions.UK as UKDimensions import qualified Duckling.Dimensions.VI as VIDimensions import qualified Duckling.Dimensions.ZH as ZHDimensions -import Duckling.Locale allDimensions :: Lang -> [Some Dimension] allDimensions lang = CommonDimensions.allDimensions ++ langDimensions lang @@ -81,6 +83,7 @@ dependents (This TimeGrain) = HashSet.empty dependents (This Url) = HashSet.empty dependents (This Volume) = HashSet.singleton (This Numeral) +dependents (This (CustomDimension dim)) = dimDependents dim langDimensions :: Lang -> [Some Dimension] langDimensions AR = ARDimensions.allDimensions @@ -112,6 +115,7 @@ langDimensions RO = RODimensions.allDimensions langDimensions RU = RUDimensions.allDimensions langDimensions SV = SVDimensions.allDimensions +langDimensions TA = TADimensions.allDimensions langDimensions TR = TRDimensions.allDimensions langDimensions UK = UKDimensions.allDimensions langDimensions VI = VIDimensions.allDimensions diff --git a/Duckling/Dimensions/BG.hs b/Duckling/Dimensions/BG.hs --- a/Duckling/Dimensions/BG.hs +++ b/Duckling/Dimensions/BG.hs @@ -14,5 +14,8 @@ allDimensions :: [Some Dimension] allDimensions = - [ This Numeral + [ This Distance + , This Duration + , This Numeral + , This Ordinal ] diff --git a/Duckling/Dimensions/SV.hs b/Duckling/Dimensions/SV.hs --- a/Duckling/Dimensions/SV.hs +++ b/Duckling/Dimensions/SV.hs @@ -14,7 +14,8 @@ allDimensions :: [Some Dimension] allDimensions = - [ This Duration + [ This Distance + , This Duration , This Numeral , This Ordinal , This Time diff --git a/Duckling/Dimensions/TA.hs b/Duckling/Dimensions/TA.hs new file mode 100644 --- /dev/null +++ b/Duckling/Dimensions/TA.hs @@ -0,0 +1,18 @@ +-- Copyright (c) 2016-present, Facebook, Inc. +-- All rights reserved. +-- +-- This source code is licensed under the BSD-style license found in the +-- LICENSE file in the root directory of this source tree. An additional grant +-- of patent rights can be found in the PATENTS file in the same directory. + + +module Duckling.Dimensions.TA + ( allDimensions + ) where + +import Duckling.Dimensions.Types + +allDimensions :: [Some Dimension] +allDimensions = + [ This Numeral + ] diff --git a/Duckling/Dimensions/Types.hs b/Duckling/Dimensions/Types.hs --- a/Duckling/Dimensions/Types.hs +++ b/Duckling/Dimensions/Types.hs @@ -6,12 +6,8 @@ -- of patent rights can be found in the PATENTS file in the same directory. - -{-# LANGUAGE ExistentialQuantification #-} -{-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE NoRebindableSyntax #-} -{-# LANGUAGE TypeOperators #-} module Duckling.Dimensions.Types @@ -22,99 +18,14 @@ , toName ) where -import Data.GADT.Compare -import Data.GADT.Show -import Data.Hashable -import qualified Data.HashMap.Strict as HashMap import Data.Maybe import Data.Some import Data.Text (Text) --- Intentionally limit use of Typeable to avoid casting or typeOf usage -import Data.Typeable ((:~:)(..)) -import TextShow (TextShow(..)) -import qualified TextShow as TS import Prelude - -import Duckling.AmountOfMoney.Types (AmountOfMoneyData) -import Duckling.Distance.Types (DistanceData) -import Duckling.Duration.Types (DurationData) -import Duckling.Email.Types (EmailData) -import Duckling.Numeral.Types (NumeralData) -import Duckling.Ordinal.Types (OrdinalData) -import Duckling.PhoneNumber.Types (PhoneNumberData) -import Duckling.Quantity.Types (QuantityData) -import Duckling.Regex.Types (GroupMatch) -import Duckling.Temperature.Types (TemperatureData) -import Duckling.Time.Types (TimeData) -import Duckling.TimeGrain.Types (Grain) -import Duckling.Url.Types (UrlData) -import Duckling.Volume.Types (VolumeData) - --- ----------------------------------------------------------------- --- Dimension - --- | GADT for differentiating between dimensions --- Each dimension should have its own constructor and provide the data structure --- for its parsed data -data Dimension a where - RegexMatch :: Dimension GroupMatch - AmountOfMoney :: Dimension AmountOfMoneyData - Distance :: Dimension DistanceData - Duration :: Dimension DurationData - Email :: Dimension EmailData - Numeral :: Dimension NumeralData - Ordinal :: Dimension OrdinalData - PhoneNumber :: Dimension PhoneNumberData - Quantity :: Dimension QuantityData - Temperature :: Dimension TemperatureData - Time :: Dimension TimeData - TimeGrain :: Dimension Grain - Url :: Dimension UrlData - Volume :: Dimension VolumeData - --- Show -instance Show (Dimension a) where - show RegexMatch = "RegexMatch" - show Distance = "Distance" - show Duration = "Duration" - show Email = "Email" - show AmountOfMoney = "AmountOfMoney" - show Numeral = "Numeral" - show Ordinal = "Ordinal" - show PhoneNumber = "PhoneNumber" - show Quantity = "Quantity" - show Temperature = "Temperature" - show Time = "Time" - show TimeGrain = "TimeGrain" - show Url = "Url" - show Volume = "Volume" -instance GShow Dimension where gshowsPrec = showsPrec - --- TextShow -instance TextShow (Dimension a) where - showb d = TS.fromString $ show d -instance TextShow (Some Dimension) where - showb (This d) = showb d - --- Hashable -instance Hashable (Some Dimension) where - hashWithSalt s (This a) = hashWithSalt s a -instance Hashable (Dimension a) where - hashWithSalt s RegexMatch = hashWithSalt s (0::Int) - hashWithSalt s Distance = hashWithSalt s (1::Int) - hashWithSalt s Duration = hashWithSalt s (2::Int) - hashWithSalt s Email = hashWithSalt s (3::Int) - hashWithSalt s AmountOfMoney = hashWithSalt s (4::Int) - hashWithSalt s Numeral = hashWithSalt s (5::Int) - hashWithSalt s Ordinal = hashWithSalt s (6::Int) - hashWithSalt s PhoneNumber = hashWithSalt s (7::Int) - hashWithSalt s Quantity = hashWithSalt s (8::Int) - hashWithSalt s Temperature = hashWithSalt s (9::Int) - hashWithSalt s Time = hashWithSalt s (10::Int) - hashWithSalt s TimeGrain = hashWithSalt s (11::Int) - hashWithSalt s Url = hashWithSalt s (12::Int) - hashWithSalt s Volume = hashWithSalt s (13::Int) +import qualified Data.HashMap.Strict as HashMap +import qualified Data.Text as Text +import Duckling.Types toName :: Dimension a -> Text toName RegexMatch = "regex" @@ -131,6 +42,7 @@ toName TimeGrain = "time-grain" toName Url = "url" toName Volume = "volume" +toName (CustomDimension dim) = Text.pack (show dim) fromName :: Text -> Maybe (Some Dimension) fromName name = HashMap.lookup name m @@ -149,33 +61,3 @@ , ("url", This Url) , ("volume", This Volume) ] - -instance GEq Dimension where - geq RegexMatch RegexMatch = Just Refl - geq RegexMatch _ = Nothing - geq Distance Distance = Just Refl - geq Distance _ = Nothing - geq Duration Duration = Just Refl - geq Duration _ = Nothing - geq Email Email = Just Refl - geq Email _ = Nothing - geq AmountOfMoney AmountOfMoney = Just Refl - geq AmountOfMoney _ = Nothing - geq Numeral Numeral = Just Refl - geq Numeral _ = Nothing - geq Ordinal Ordinal = Just Refl - geq Ordinal _ = Nothing - geq PhoneNumber PhoneNumber = Just Refl - geq PhoneNumber _ = Nothing - geq Quantity Quantity = Just Refl - geq Quantity _ = Nothing - geq Temperature Temperature = Just Refl - geq Temperature _ = Nothing - geq Time Time = Just Refl - geq Time _ = Nothing - geq TimeGrain TimeGrain = Just Refl - geq TimeGrain _ = Nothing - geq Url Url = Just Refl - geq Url _ = Nothing - geq Volume Volume = Just Refl - geq Volume _ = Nothing diff --git a/Duckling/Dimensions/ZH.hs b/Duckling/Dimensions/ZH.hs --- a/Duckling/Dimensions/ZH.hs +++ b/Duckling/Dimensions/ZH.hs @@ -14,7 +14,8 @@ allDimensions :: [Some Dimension] allDimensions = - [ This Duration + [ This Distance + , This Duration , This Numeral , This Ordinal , This Temperature diff --git a/Duckling/Distance/BG/Corpus.hs b/Duckling/Distance/BG/Corpus.hs new file mode 100644 --- /dev/null +++ b/Duckling/Distance/BG/Corpus.hs @@ -0,0 +1,66 @@ +-- Copyright (c) 2016-present, Facebook, Inc. +-- All rights reserved. +-- +-- This source code is licensed under the BSD-style license found in the +-- LICENSE file in the root directory of this source tree. An additional grant +-- of patent rights can be found in the PATENTS file in the same directory. + + +{-# LANGUAGE OverloadedStrings #-} + +module Duckling.Distance.BG.Corpus + ( corpus + ) where + +import Data.String +import Prelude + +import Duckling.Locale +import Duckling.Resolve +import Duckling.Distance.Types +import Duckling.Testing.Types + +corpus :: Corpus +corpus = (testContext {locale = makeLocale BG Nothing}, testOptions, allExamples) + +allExamples :: [Example] +allExamples = concat + [ examples (simple Kilometre 3) + [ "3 километра" + , "3 км" + , "3км" + , "3.0 км" + ] + , examples (simple Mile 8) + [ "8 мили" + , "осем мили" + ] + , examples (simple Metre 1) + [ "1 м", + "1 метър", + "един метър" + ] + , examples (simple Centimetre 2) + [ "2см" + , "2 сантиметра" + ] + , examples (simple Millimetre 4) + [ "4мм" + , "4 милиметра" + ] + , examples (simple Inch 5) + [ "5 инча" + , "5''" + , "пет инча" + , "5\"" + ] + , examples (simple Foot 35) + [ "35 фута" + , "35'" + , "тридесет и пет фута" + ] + , examples (simple Yard 47) + [ "47 ярда" + , "четиридесет и седем ярда" + ] + ] diff --git a/Duckling/Distance/BG/Rules.hs b/Duckling/Distance/BG/Rules.hs new file mode 100644 --- /dev/null +++ b/Duckling/Distance/BG/Rules.hs @@ -0,0 +1,50 @@ +-- Copyright (c) 2016-present, Facebook, Inc. +-- All rights reserved. +-- +-- This source code is licensed under the BSD-style license found in the +-- LICENSE file in the root directory of this source tree. An additional grant +-- of patent rights can be found in the PATENTS file in the same directory. + + +{-# LANGUAGE GADTs #-} +{-# LANGUAGE OverloadedStrings #-} + +module Duckling.Distance.BG.Rules + ( rules + ) where + +import Data.String +import Data.Text (Text) +import Prelude + +import Duckling.Dimensions.Types +import Duckling.Distance.Helpers +import Duckling.Distance.Types (DistanceData(..)) +import Duckling.Types +import qualified Duckling.Distance.Types as TDistance + +distances :: [(Text, String, TDistance.Unit)] +distances = [ (" km", "км|километ(ра|ри|ър)", TDistance.Kilometre) + , (" feet", "('|фут(а|ове)?)", TDistance.Foot) + , (" inch", "(\"|''|инч(а|ове)?)", TDistance.Inch) + , (" yard", "ярд(а|ове)?", TDistance.Yard) + , (" meters", "м(етър|етр(а|и))?", TDistance.Metre) + , (" centimeters", "см|сантимет(ри|ра|ър)", TDistance.Centimetre) + , (" millimeters", "мм|милимет(ра|ри|ър)", TDistance.Millimetre) + , (" miles", "мил(я|и)", TDistance.Mile) + ] + +ruleDistances :: [Rule] +ruleDistances = map go distances + where + go :: (Text, String, TDistance.Unit) -> Rule + go (name, regexPattern, u) = Rule + { name = name + , pattern = [ dimension Distance, regex regexPattern ] + , prod = \tokens -> case tokens of + (Token Distance dd:_) -> Just . Token Distance $ withUnit u dd + _ -> Nothing + } + +rules :: [Rule] +rules = ruleDistances diff --git a/Duckling/Distance/CS/Corpus.hs b/Duckling/Distance/CS/Corpus.hs --- a/Duckling/Distance/CS/Corpus.hs +++ b/Duckling/Distance/CS/Corpus.hs @@ -21,7 +21,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale CS Nothing}, allExamples) +corpus = (testContext {locale = makeLocale CS Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Distance/EN/Corpus.hs b/Duckling/Distance/EN/Corpus.hs --- a/Duckling/Distance/EN/Corpus.hs +++ b/Duckling/Distance/EN/Corpus.hs @@ -9,16 +9,17 @@ {-# LANGUAGE OverloadedStrings #-} module Duckling.Distance.EN.Corpus - ( corpus ) where + ( corpus + ) where -import Prelude import Data.String +import Prelude import Duckling.Distance.Types import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext, allExamples) +corpus = (testContext, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Distance/ES/Corpus.hs b/Duckling/Distance/ES/Corpus.hs --- a/Duckling/Distance/ES/Corpus.hs +++ b/Duckling/Distance/ES/Corpus.hs @@ -21,7 +21,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale ES Nothing}, allExamples) +corpus = (testContext {locale = makeLocale ES Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Distance/FR/Corpus.hs b/Duckling/Distance/FR/Corpus.hs --- a/Duckling/Distance/FR/Corpus.hs +++ b/Duckling/Distance/FR/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale FR Nothing}, allExamples) +corpus = (testContext {locale = makeLocale FR Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Distance/GA/Corpus.hs b/Duckling/Distance/GA/Corpus.hs --- a/Duckling/Distance/GA/Corpus.hs +++ b/Duckling/Distance/GA/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale GA Nothing}, allExamples) +corpus = (testContext {locale = makeLocale GA Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Distance/HR/Corpus.hs b/Duckling/Distance/HR/Corpus.hs --- a/Duckling/Distance/HR/Corpus.hs +++ b/Duckling/Distance/HR/Corpus.hs @@ -19,7 +19,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale HR Nothing}, allExamples) +corpus = (testContext {locale = makeLocale HR Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Distance/KO/Corpus.hs b/Duckling/Distance/KO/Corpus.hs --- a/Duckling/Distance/KO/Corpus.hs +++ b/Duckling/Distance/KO/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale KO Nothing}, allExamples) +corpus = (testContext {locale = makeLocale KO Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Distance/NL/Corpus.hs b/Duckling/Distance/NL/Corpus.hs --- a/Duckling/Distance/NL/Corpus.hs +++ b/Duckling/Distance/NL/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale NL Nothing}, allExamples) +corpus = (testContext {locale = makeLocale NL Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Distance/PT/Corpus.hs b/Duckling/Distance/PT/Corpus.hs --- a/Duckling/Distance/PT/Corpus.hs +++ b/Duckling/Distance/PT/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale PT Nothing}, allExamples) +corpus = (testContext {locale = makeLocale PT Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Distance/RO/Corpus.hs b/Duckling/Distance/RO/Corpus.hs --- a/Duckling/Distance/RO/Corpus.hs +++ b/Duckling/Distance/RO/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale RO Nothing}, allExamples) +corpus = (testContext {locale = makeLocale RO Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Distance/RU/Corpus.hs b/Duckling/Distance/RU/Corpus.hs --- a/Duckling/Distance/RU/Corpus.hs +++ b/Duckling/Distance/RU/Corpus.hs @@ -21,7 +21,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale RU Nothing}, allExamples) +corpus = (testContext {locale = makeLocale RU Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Distance/Rules.hs b/Duckling/Distance/Rules.hs --- a/Duckling/Distance/Rules.hs +++ b/Duckling/Distance/Rules.hs @@ -20,8 +20,8 @@ import Duckling.Dimensions.Types import Duckling.Distance.Helpers import Duckling.Numeral.Types (NumeralData (..)) -import qualified Duckling.Numeral.Types as TNumeral import Duckling.Types +import qualified Duckling.Numeral.Types as TNumeral ruleNumeralAsDistance :: Rule ruleNumeralAsDistance = Rule diff --git a/Duckling/Distance/SV/Corpus.hs b/Duckling/Distance/SV/Corpus.hs new file mode 100644 --- /dev/null +++ b/Duckling/Distance/SV/Corpus.hs @@ -0,0 +1,50 @@ +-- Copyright (c) 2016-present, Facebook, Inc. +-- All rights reserved. +-- +-- This source code is licensed under the BSD-style license found in the +-- LICENSE file in the root directory of this source tree. An additional grant +-- of patent rights can be found in the PATENTS file in the same directory. + + +{-# LANGUAGE OverloadedStrings #-} + +module Duckling.Distance.SV.Corpus + ( corpus + ) where + +import Data.String +import Prelude + +import Duckling.Distance.Types +import Duckling.Locale +import Duckling.Resolve +import Duckling.Testing.Types + +corpus :: Corpus +corpus = (testContext {locale = makeLocale SV Nothing}, testOptions, allExamples) + +allExamples :: [Example] +allExamples = concat + [ examples (simple Kilometre 3) + [ "3 kilometer" + , "3 km" + , "3km" + , "3k" + ] + , examples (simple Kilometre 30) + [ "3 mil" + , "tre mil" + , "några få mil" + ] + , examples (simple Kilometre 3.0) + [ "3,0 km" + ] + , examples (simple Metre 9) + [ "9 meter" + , "9m" + ] + , examples (simple Centimetre 2) + [ "2cm" + , "2 centimeter" + ] + ] diff --git a/Duckling/Distance/SV/Rules.hs b/Duckling/Distance/SV/Rules.hs new file mode 100644 --- /dev/null +++ b/Duckling/Distance/SV/Rules.hs @@ -0,0 +1,84 @@ +-- Copyright (c) 2016-present, Facebook, Inc. +-- All rights reserved. +-- +-- This source code is licensed under the BSD-style license found in the +-- LICENSE file in the root directory of this source tree. An additional grant +-- of patent rights can be found in the PATENTS file in the same directory. + + +{-# LANGUAGE GADTs #-} +{-# LANGUAGE OverloadedStrings #-} + +module Duckling.Distance.SV.Rules + ( rules + ) where + +import Data.String +import Prelude + +import Duckling.Dimensions.Types +import Duckling.Distance.Helpers +import Duckling.Distance.Types (DistanceData(..)) +import Duckling.Types +import qualified Duckling.Distance.Types as TDistance + +ruleLatentDistKm :: Rule +ruleLatentDistKm = Rule + { name = " km" + , pattern = + [ dimension Distance + , regex "k(ilo)?m?(eter)?" + ] + , prod = \tokens -> case tokens of + (Token Distance dd:_) -> + Just . Token Distance $ withUnit TDistance.Kilometre dd + _ -> Nothing + } + +ruleDistMeters :: Rule +ruleDistMeters = Rule + { name = " meter" + , pattern = + [ dimension Distance + , regex "m(eter)?" + ] + , prod = \tokens -> case tokens of + (Token Distance dd:_) -> + Just . Token Distance $ withUnit TDistance.Metre dd + _ -> Nothing + } + +ruleDistCentimeters :: Rule +ruleDistCentimeters = Rule + { name = " centimeters" + , pattern = + [ dimension Distance + , regex "cm|centimeter" + ] + , prod = \tokens -> case tokens of + (Token Distance dd:_) -> + Just . Token Distance $ withUnit TDistance.Centimetre dd + _ -> Nothing + } + +ruleDistMils :: Rule +ruleDistMils = Rule + { name = " mils" + , pattern = + [ dimension Distance + , regex "mils?" + ] + , prod = \tokens -> case tokens of + (Token Distance dd@DistanceData {TDistance.value = Just x}:_) -> + Just . Token Distance . withValue (10 * x) + $ withUnit TDistance.Kilometre dd + _ -> Nothing + } + +rules :: [Rule] +rules = + [ ruleDistCentimeters + , ruleDistMeters + , ruleDistMils + , ruleLatentDistKm + ] diff --git a/Duckling/Distance/TR/Corpus.hs b/Duckling/Distance/TR/Corpus.hs --- a/Duckling/Distance/TR/Corpus.hs +++ b/Duckling/Distance/TR/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale TR Nothing}, allExamples) +corpus = (testContext {locale = makeLocale TR Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Distance/Types.hs b/Duckling/Distance/Types.hs --- a/Duckling/Distance/Types.hs +++ b/Duckling/Distance/Types.hs @@ -51,18 +51,18 @@ instance Resolve DistanceData where type ResolvedValue DistanceData = DistanceValue - resolve _ DistanceData {unit = Just unit, value = Just val} = - Just $ simple unit val - resolve _ DistanceData {unit = Just unit, value = Nothing + resolve _ _ DistanceData {unit = Just unit, value = Just val} = + Just (simple unit val, False) + resolve _ _ DistanceData {unit = Just unit, value = Nothing , minValue = Just from, maxValue = Just to} = - Just $ between unit (from, to) - resolve _ DistanceData {unit = Just unit, value = Nothing + Just (between unit (from, to), False) + resolve _ _ DistanceData {unit = Just unit, value = Nothing , minValue = Just from, maxValue = Nothing} = - Just $ above unit from - resolve _ DistanceData {unit = Just unit, value = Nothing + Just (above unit from, False) + resolve _ _ DistanceData {unit = Just unit, value = Nothing , minValue = Nothing, maxValue = Just to} = - Just $ under unit to - resolve _ _ = Nothing + Just (under unit to, False) + resolve _ _ _ = Nothing data IntervalDirection = Above | Under deriving (Eq, Generic, Hashable, Ord, Show, NFData) diff --git a/Duckling/Distance/ZH/Corpus.hs b/Duckling/Distance/ZH/Corpus.hs new file mode 100644 --- /dev/null +++ b/Duckling/Distance/ZH/Corpus.hs @@ -0,0 +1,72 @@ +-- Copyright (c) 2016-present, Facebook, Inc. +-- All rights reserved. +-- +-- This source code is licensed under the BSD-style license found in the +-- LICENSE file in the root directory of this source tree. An additional grant +-- of patent rights can be found in the PATENTS file in the same directory. + + +{-# LANGUAGE OverloadedStrings #-} + +module Duckling.Distance.ZH.Corpus + ( corpus ) where + +import Data.String +import Prelude + +import Duckling.Distance.Types +import Duckling.Locale +import Duckling.Resolve +import Duckling.Testing.Types + +corpus :: Corpus +corpus = (testContext {locale = makeLocale ZH Nothing}, testOptions, allExamples) + +allExamples :: [Example] +allExamples = concat + [ examples (simple Centimetre 2) + [ "2cm" + , "2 厘米" + , "二厘米" + , "2公分" + , "二公分" + ] + , examples (simple Metre 9) + [ "9m" + , "9 m" + , "九米" + , "9公尺" + ] + , examples (simple Kilometre 3) + [ "3公里" + , "三公裏" + , "3 km" + , "3km" + ] + , examples (simple Kilometre 3.0) + [ "3.0 公里" + ] + , examples (simple Foot 8) + [ "8 foot" + , "8 feet" + , "8 foots" + , "8 feets" + , "8'" + , "8英尺" + , "8呎" + ] + , examples (simple Inch 4) + [ "4 inch" + , "4 inches" + , "4''" + , "4英寸" + , "4英吋" + , "四吋" + ] + , examples (simple Mile 1) + [ "1 mile" + , "1 miles" + , "1英里" + , "一英裏" + ] + ] diff --git a/Duckling/Distance/ZH/Rules.hs b/Duckling/Distance/ZH/Rules.hs new file mode 100644 --- /dev/null +++ b/Duckling/Distance/ZH/Rules.hs @@ -0,0 +1,129 @@ +-- Copyright (c) 2016-present, Facebook, Inc. +-- All rights reserved. +-- +-- This source code is licensed under the BSD-style license found in the +-- LICENSE file in the root directory of this source tree. An additional grant +-- of patent rights can be found in the PATENTS file in the same directory. + + +{-# LANGUAGE GADTs #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE OverloadedStrings #-} + +module Duckling.Distance.ZH.Rules + ( rules ) where + +import Data.String +import Prelude + +import Duckling.Dimensions.Types +import Duckling.Distance.Helpers +import Duckling.Numeral.Types (NumeralData (..)) +import Duckling.Types +import qualified Duckling.Distance.Types as TDistance +import qualified Duckling.Numeral.Types as TNumeral + +ruleDistCentimeters :: Rule +ruleDistCentimeters = Rule + { name = " centimeters" + , pattern = + [ dimension Distance + , regex "cm|厘米|公分" + ] + , prod = \case + (Token Distance dd:_) -> + Just . Token Distance $ withUnit TDistance.Centimetre dd + _ -> Nothing + } + +ruleDistMeters :: Rule +ruleDistMeters = Rule + { name = " meters" + , pattern = + [ dimension Distance + , regex "m|米|公尺" + ] + , prod = \case + (Token Distance dd:_) -> + Just . Token Distance $ withUnit TDistance.Metre dd + _ -> Nothing + } + +ruleDistKm :: Rule +ruleDistKm = Rule + { name = " km" + , pattern = + [ dimension Distance + , regex "km|千米|公(里|裏)" + ] + , prod = \case + (Token Distance dd:_) -> + Just . Token Distance $ withUnit TDistance.Kilometre dd + _ -> Nothing + } + + +ruleDistFeetAndDistInch :: Rule +ruleDistFeetAndDistInch = Rule + { name = " feet and inch " + , pattern = + [ dimension Distance + , regex "'|f(oo|ee)?ts?|英尺|呎" + , dimension Distance + , regex "''|inch(es)?|英寸|英吋|吋" + ] + , prod = \case + (Token Distance dd:_) -> + Just . Token Distance $ withUnit TDistance.Foot dd + _ -> Nothing + } + +ruleDistInch :: Rule +ruleDistInch = Rule + { name = " inch" + , pattern = + [ dimension Distance + , regex "''|inch(es)?|英寸|英吋|吋" + ] + , prod = \case + (Token Distance dd:_) -> + Just . Token Distance $ withUnit TDistance.Inch dd + _ -> Nothing + } + +ruleDistFeet :: Rule +ruleDistFeet = Rule + { name = " feet" + , pattern = + [ dimension Distance + , regex "'|f(oo|ee)?ts?|英尺|呎" + ] + , prod = \case + (Token Distance dd:_) -> + Just . Token Distance $ withUnit TDistance.Foot dd + _ -> Nothing + } + +ruleDistMiles :: Rule +ruleDistMiles = Rule + { name = " miles" + , pattern = + [ dimension Distance + , regex "miles?|英(里|裏)" + ] + , prod = \case + (Token Distance dd:_) -> + Just . Token Distance $ withUnit TDistance.Mile dd + _ -> Nothing + } + +rules :: [Rule] +rules = + [ ruleDistCentimeters + , ruleDistFeet + , ruleDistFeetAndDistInch + , ruleDistInch + , ruleDistKm + , ruleDistMeters + , ruleDistMiles + ] diff --git a/Duckling/Duration/AR/Corpus.hs b/Duckling/Duration/AR/Corpus.hs --- a/Duckling/Duration/AR/Corpus.hs +++ b/Duckling/Duration/AR/Corpus.hs @@ -22,7 +22,7 @@ import Duckling.TimeGrain.Types (Grain(..)) corpus :: Corpus -corpus = (testContext {locale = makeLocale AR Nothing}, allExamples) +corpus = (testContext {locale = makeLocale AR Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Duration/BG/Corpus.hs b/Duckling/Duration/BG/Corpus.hs new file mode 100644 --- /dev/null +++ b/Duckling/Duration/BG/Corpus.hs @@ -0,0 +1,95 @@ +-- Copyright (c) 2016-present, Facebook, Inc. +-- All rights reserved. +-- +-- This source code is licensed under the BSD-style license found in the +-- LICENSE file in the root directory of this source tree. An additional grant +-- of patent rights can be found in the PATENTS file in the same directory. + + +{-# LANGUAGE OverloadedStrings #-} + +module Duckling.Duration.BG.Corpus + ( corpus + ) where + +import Data.String +import Prelude + +import Duckling.Duration.Types +import Duckling.Locale +import Duckling.Resolve +import Duckling.Testing.Types +import Duckling.TimeGrain.Types (Grain(..)) + +corpus :: Corpus +corpus = (testContext {locale = makeLocale BG Nothing}, testOptions, allExamples) + +allExamples :: [Example] +allExamples = concat + [ examples (DurationData 1 Second) + [ "1 сек" + , "1 секунда" + , "секунда" + , "1\"" + ] + , examples (DurationData 15 Minute) + [ "15 мин" + , "петнадесет минути" + , "15'" + ] + , examples (DurationData 30 Minute) + [ "30 минути" + , "половин час" + , "тридесет минути" + ] + , examples (DurationData 90 Minute) + [ "час и половина" + , "90 мин" + ] + , examples (DurationData 5400 Second) + [ "1.5 часа" + , "5400 секунди" + ] + , examples (DurationData 8 Hour) + [ "8 часа" + , "8 ч" + , "осем часа" + ] + , examples (DurationData 15 Day) + [ "15 дни" + , "петнадесет дни" + , "половин месец" + ] + , examples (DurationData 7 Week) + [ "7 седмици" + , "седем седмици" + ] + , examples (DurationData 1 Month) + [ "1 месец" + , "месец" + ] + , examples (DurationData 6 Month) + [ "6 месеца" + , "шест месеца" + , "половин година" + ] + , examples (DurationData 9072000 Second) + [ "3.5 месеца" + , "приблизително 3.5 месеца" + ] + , examples (DurationData 30 Month) + [ "две години и половина" + , "2 години и половина" + ] + , examples (DurationData 3 Quarter) + [ "3 тримесечия" + ] + , examples (DurationData 2 Year) + [ "2 години" + , "две години" + ] + , examples (DurationData 12 Hour) + [ "12 часа" + , "дванадесет часа" + ] + ] diff --git a/Duckling/Duration/BG/Rules.hs b/Duckling/Duration/BG/Rules.hs new file mode 100644 --- /dev/null +++ b/Duckling/Duration/BG/Rules.hs @@ -0,0 +1,134 @@ +-- Copyright (c) 2016-present, Facebook, Inc. +-- All rights reserved. +-- +-- This source code is licensed under the BSD-style license found in the +-- LICENSE file in the root directory of this source tree. An additional grant +-- of patent rights can be found in the PATENTS file in the same directory. + + +{-# LANGUAGE GADTs #-} +{-# LANGUAGE NoRebindableSyntax #-} +{-# LANGUAGE OverloadedStrings #-} + +module Duckling.Duration.BG.Rules + ( rules + ) where + +import Data.String +import Data.Text (Text) +import Prelude +import qualified Data.Text as Text + +import Duckling.Dimensions.Types +import Duckling.Duration.Helpers +import Duckling.Numeral.Helpers (numberWith) +import Duckling.Numeral.Types (NumeralData(..), isInteger) +import Duckling.Duration.Types (DurationData (DurationData)) +import Duckling.Regex.Types +import Duckling.Types +import Duckling.TimeGrain.Types +import qualified Duckling.Numeral.Types as TNumeral + +ruleHalves :: Rule +ruleHalves = Rule + { name = "half of a " + , pattern = + [ regex "половин" + , dimension TimeGrain + ] + , prod = \tokens -> case tokens of + (_:Token TimeGrain grain:_) -> Token Duration <$> timesOneAndAHalf grain 0 + _ -> Nothing + } + +ruleGrainAndAHalf :: Rule +ruleGrainAndAHalf = Rule + { name = " and a half" + , pattern = + [ dimension TimeGrain + , regex "и половина" + ] + , prod = \tokens -> case tokens of + (Token TimeGrain grain:_) -> Token Duration <$> timesOneAndAHalf grain 1 + _ -> Nothing + } + +ruleDurationAndAHalf :: Rule +ruleDurationAndAHalf = Rule + { name = " and a half" + , pattern = + [ Predicate isNatural + , dimension TimeGrain + , regex "и половина" + ] + , prod = \tokens -> case tokens of + (Token Numeral NumeralData{TNumeral.value = v}: + Token TimeGrain grain: + _) -> timesOneAndAHalf grain (floor $ v) >>= Just . Token Duration + _ -> Nothing + } + +ruleNumeralQuotes :: Rule +ruleNumeralQuotes = Rule + { name = " + '\"" + , pattern = + [ Predicate isNatural + , regex "(['\"])" + ] + , prod = \tokens -> case tokens of + (Token Numeral NumeralData{TNumeral.value = v}: + Token RegexMatch (GroupMatch (x:_)): + _) -> case x of + "'" -> Just . Token Duration . duration Minute $ floor v + "\"" -> Just . Token Duration . duration Second $ floor v + _ -> Nothing + _ -> Nothing + } + +ruleDurationPrecision :: Rule +ruleDurationPrecision = Rule + { name = "about|exactly " + , pattern = + [ regex "(към|приблизително|примерно|някъде)" + , dimension Duration + ] + , prod = \tokens -> case tokens of + (_:token:_) -> Just token + _ -> Nothing + } + +ruleGrainAsDuration :: Rule +ruleGrainAsDuration = Rule + { name = "a " + , pattern = + [ dimension TimeGrain + ] + , prod = \tokens -> case tokens of + (Token TimeGrain grain:_) -> Just . Token Duration $ duration grain 1 + _ -> Nothing + } + +rulePositiveDuration :: Rule +rulePositiveDuration = Rule + { name = " " + , pattern = + [ numberWith TNumeral.value $ and . sequence [not . isInteger, (>0)] + , dimension TimeGrain + ] + , prod = \tokens -> case tokens of + (Token Numeral NumeralData{TNumeral.value = v}: + Token TimeGrain grain: + _) -> Just . Token Duration . duration Second . floor $ inSeconds grain v + _ -> Nothing + } + +rules :: [Rule] +rules = + [ ruleDurationAndAHalf + , ruleGrainAndAHalf + , rulePositiveDuration + , ruleDurationPrecision + , ruleNumeralQuotes + , ruleGrainAsDuration + , ruleHalves + ] diff --git a/Duckling/Duration/EL/Corpus.hs b/Duckling/Duration/EL/Corpus.hs --- a/Duckling/Duration/EL/Corpus.hs +++ b/Duckling/Duration/EL/Corpus.hs @@ -26,10 +26,10 @@ context = testContext {locale = makeLocale EL Nothing} corpus :: Corpus -corpus = (context, allExamples) +corpus = (context, testOptions, allExamples) negativeCorpus :: NegativeCorpus -negativeCorpus = (context, examples) +negativeCorpus = (context, testOptions, examples) where examples = [ "για μήνες" diff --git a/Duckling/Duration/EN/Corpus.hs b/Duckling/Duration/EN/Corpus.hs --- a/Duckling/Duration/EN/Corpus.hs +++ b/Duckling/Duration/EN/Corpus.hs @@ -21,10 +21,10 @@ import Duckling.TimeGrain.Types (Grain(..)) corpus :: Corpus -corpus = (testContext, allExamples) +corpus = (testContext, testOptions, allExamples) negativeCorpus :: NegativeCorpus -negativeCorpus = (testContext, examples) +negativeCorpus = (testContext, testOptions, examples) where examples = [ "for months" @@ -61,5 +61,12 @@ ] , examples (DurationData 2 Year) [ "2 years" + ] + , examples (DurationData 27 Month) + [ "2 years and 3 months" + , "2 years, 3 months" + ] + , examples (DurationData 31719604 Second) + [ "1 year, 2 days, 3 hours and 4 seconds" ] ] diff --git a/Duckling/Duration/EN/Rules.hs b/Duckling/Duration/EN/Rules.hs --- a/Duckling/Duration/EN/Rules.hs +++ b/Duckling/Duration/EN/Rules.hs @@ -7,6 +7,7 @@ {-# LANGUAGE GADTs #-} +{-# LANGUAGE LambdaCase #-} {-# LANGUAGE NoRebindableSyntax #-} {-# LANGUAGE OverloadedStrings #-} @@ -14,16 +15,19 @@ ( rules ) where +import Data.Semigroup ((<>)) import Data.String import Prelude import qualified Data.Text as Text import Duckling.Dimensions.Types import Duckling.Duration.Helpers +import Duckling.Duration.Types (DurationData(..)) import Duckling.Numeral.Helpers (parseInt, parseInteger) import Duckling.Numeral.Types (NumeralData(..)) import Duckling.Regex.Types import Duckling.Types +import qualified Duckling.Duration.Types as TDuration import qualified Duckling.Numeral.Types as TNumeral import qualified Duckling.TimeGrain.Types as TG @@ -70,7 +74,7 @@ [ Predicate isNatural , regex "(['\"])" ] - , prod = \tokens -> case tokens of + , prod = \case (Token Numeral NumeralData{TNumeral.value = v}: Token RegexMatch (GroupMatch (x:_)): _) -> case x of @@ -88,7 +92,7 @@ , regex "more|less" , dimension TimeGrain ] - , prod = \tokens -> case tokens of + , prod = \case (Token Numeral nd:_:Token TimeGrain grain:_) -> Just . Token Duration . duration grain . floor $ TNumeral.value nd _ -> Nothing @@ -100,7 +104,7 @@ , pattern = [ regex "(\\d+)\\.(\\d+) *hours?" ] - , prod = \tokens -> case tokens of + , prod = \case (Token RegexMatch (GroupMatch (h:m:_)):_) -> do hh <- parseInteger h mnum <- parseInteger m @@ -116,7 +120,7 @@ [ Predicate isNatural , regex "and (an? )?half hours?" ] - , prod = \tokens -> case tokens of + , prod = \case (Token Numeral NumeralData{TNumeral.value = v}:_) -> Just . Token Duration . duration TG.Minute $ 30 + 60 * floor v _ -> Nothing @@ -129,7 +133,7 @@ [ regex "an?" , dimension TimeGrain ] - , prod = \tokens -> case tokens of + , prod = \case (_:Token TimeGrain grain:_) -> Just . Token Duration $ duration grain 1 _ -> Nothing } @@ -141,11 +145,29 @@ [ regex "(about|around|approximately|exactly)" , dimension Duration ] - , prod = \tokens -> case tokens of + , prod = \case (_:token:_) -> Just token _ -> Nothing } +ruleCompositeDuration :: Rule +ruleCompositeDuration = Rule + { name = "composite " + , pattern = + [ Predicate isNatural + , dimension TimeGrain + , regex ",|and" + , dimension Duration + ] + , prod = \case + (Token Numeral NumeralData{TNumeral.value = v}: + Token TimeGrain g: + _: + Token Duration dd@DurationData{TDuration.grain = dg}: + _) | g > dg -> Just . Token Duration $ duration g (floor v) <> dd + _ -> Nothing + } + rules :: [Rule] rules = [ ruleDurationQuarterOfAnHour @@ -158,4 +180,5 @@ , ruleDurationA , ruleDurationPrecision , ruleNumeralQuotes + , ruleCompositeDuration ] diff --git a/Duckling/Duration/FR/Corpus.hs b/Duckling/Duration/FR/Corpus.hs --- a/Duckling/Duration/FR/Corpus.hs +++ b/Duckling/Duration/FR/Corpus.hs @@ -23,10 +23,10 @@ import Duckling.TimeGrain.Types (Grain(..)) corpus :: Corpus -corpus = (testContext {locale = makeLocale FR Nothing}, allExamples) +corpus = (testContext {locale = makeLocale FR Nothing}, testOptions, allExamples) negativeCorpus :: NegativeCorpus -negativeCorpus = (testContext {locale = makeLocale FR Nothing}, examples) +negativeCorpus = (testContext {locale = makeLocale FR Nothing}, testOptions, examples) where examples = [ "les jours" diff --git a/Duckling/Duration/GA/Corpus.hs b/Duckling/Duration/GA/Corpus.hs --- a/Duckling/Duration/GA/Corpus.hs +++ b/Duckling/Duration/GA/Corpus.hs @@ -22,7 +22,7 @@ import Duckling.TimeGrain.Types (Grain(..)) corpus :: Corpus -corpus = (testContext {locale = makeLocale GA Nothing}, allExamples) +corpus = (testContext {locale = makeLocale GA Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Duration/HU/Corpus.hs b/Duckling/Duration/HU/Corpus.hs --- a/Duckling/Duration/HU/Corpus.hs +++ b/Duckling/Duration/HU/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.TimeGrain.Types (Grain(..)) corpus :: Corpus -corpus = (testContext {locale = makeLocale HU Nothing}, allExamples) +corpus = (testContext {locale = makeLocale HU Nothing}, testOptions, allExamples) allExamples :: [Example] diff --git a/Duckling/Duration/JA/Corpus.hs b/Duckling/Duration/JA/Corpus.hs --- a/Duckling/Duration/JA/Corpus.hs +++ b/Duckling/Duration/JA/Corpus.hs @@ -22,7 +22,7 @@ import Duckling.TimeGrain.Types (Grain(..)) corpus :: Corpus -corpus = (testContext {locale = makeLocale JA Nothing}, allExamples) +corpus = (testContext {locale = makeLocale JA Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Duration/KO/Corpus.hs b/Duckling/Duration/KO/Corpus.hs --- a/Duckling/Duration/KO/Corpus.hs +++ b/Duckling/Duration/KO/Corpus.hs @@ -22,7 +22,7 @@ import Duckling.TimeGrain.Types (Grain(..)) corpus :: Corpus -corpus = (testContext {locale = makeLocale KO Nothing}, allExamples) +corpus = (testContext {locale = makeLocale KO Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Duration/NB/Corpus.hs b/Duckling/Duration/NB/Corpus.hs --- a/Duckling/Duration/NB/Corpus.hs +++ b/Duckling/Duration/NB/Corpus.hs @@ -22,7 +22,7 @@ import Duckling.TimeGrain.Types (Grain(..)) corpus :: Corpus -corpus = (testContext {locale = makeLocale NB Nothing}, allExamples) +corpus = (testContext {locale = makeLocale NB Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Duration/NL/Corpus.hs b/Duckling/Duration/NL/Corpus.hs --- a/Duckling/Duration/NL/Corpus.hs +++ b/Duckling/Duration/NL/Corpus.hs @@ -23,10 +23,10 @@ import Duckling.TimeGrain.Types (Grain(..)) corpus :: Corpus -corpus = (testContext {locale = makeLocale NL Nothing}, allExamples) +corpus = (testContext {locale = makeLocale NL Nothing}, testOptions, allExamples) negativeCorpus :: NegativeCorpus -negativeCorpus = (testContext {locale = makeLocale NL Nothing}, examples) +negativeCorpus = (testContext {locale = makeLocale NL Nothing}, testOptions, examples) where examples = [ "voor maanden" diff --git a/Duckling/Duration/PL/Corpus.hs b/Duckling/Duration/PL/Corpus.hs --- a/Duckling/Duration/PL/Corpus.hs +++ b/Duckling/Duration/PL/Corpus.hs @@ -22,7 +22,7 @@ import Duckling.TimeGrain.Types (Grain(..)) corpus :: Corpus -corpus = (testContext {locale = makeLocale PL Nothing}, allExamples) +corpus = (testContext {locale = makeLocale PL Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Duration/PT/Corpus.hs b/Duckling/Duration/PT/Corpus.hs --- a/Duckling/Duration/PT/Corpus.hs +++ b/Duckling/Duration/PT/Corpus.hs @@ -22,7 +22,7 @@ import Duckling.TimeGrain.Types (Grain(..)) corpus :: Corpus -corpus = (testContext {locale = makeLocale PT Nothing}, allExamples) +corpus = (testContext {locale = makeLocale PT Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Duration/RO/Corpus.hs b/Duckling/Duration/RO/Corpus.hs --- a/Duckling/Duration/RO/Corpus.hs +++ b/Duckling/Duration/RO/Corpus.hs @@ -22,7 +22,7 @@ import Duckling.TimeGrain.Types (Grain(..)) corpus :: Corpus -corpus = (testContext {locale = makeLocale RO Nothing}, allExamples) +corpus = (testContext {locale = makeLocale RO Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Duration/RU/Corpus.hs b/Duckling/Duration/RU/Corpus.hs --- a/Duckling/Duration/RU/Corpus.hs +++ b/Duckling/Duration/RU/Corpus.hs @@ -22,7 +22,7 @@ import Duckling.TimeGrain.Types (Grain(..)) corpus :: Corpus -corpus = (testContext {locale = makeLocale RU Nothing}, allExamples) +corpus = (testContext {locale = makeLocale RU Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Duration/Rules.hs b/Duckling/Duration/Rules.hs --- a/Duckling/Duration/Rules.hs +++ b/Duckling/Duration/Rules.hs @@ -7,6 +7,7 @@ {-# LANGUAGE GADTs #-} +{-# LANGUAGE LambdaCase #-} {-# LANGUAGE OverloadedStrings #-} module Duckling.Duration.Rules @@ -29,7 +30,7 @@ [ Predicate isNatural , dimension TimeGrain ] - , prod = \tokens -> case tokens of + , prod = \case (Token Numeral NumeralData{TNumeral.value = v}: Token TimeGrain grain: _) -> Just . Token Duration . duration grain $ floor v diff --git a/Duckling/Duration/SV/Corpus.hs b/Duckling/Duration/SV/Corpus.hs --- a/Duckling/Duration/SV/Corpus.hs +++ b/Duckling/Duration/SV/Corpus.hs @@ -22,7 +22,7 @@ import Duckling.TimeGrain.Types (Grain(..)) corpus :: Corpus -corpus = (testContext {locale = makeLocale SV Nothing}, allExamples) +corpus = (testContext {locale = makeLocale SV Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Duration/TR/Corpus.hs b/Duckling/Duration/TR/Corpus.hs --- a/Duckling/Duration/TR/Corpus.hs +++ b/Duckling/Duration/TR/Corpus.hs @@ -22,7 +22,7 @@ import Duckling.TimeGrain.Types (Grain (..)) corpus :: Corpus -corpus = (testContext {locale = makeLocale TR Nothing}, allExamples) +corpus = (testContext {locale = makeLocale TR Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Duration/Types.hs b/Duckling/Duration/Types.hs --- a/Duckling/Duration/Types.hs +++ b/Duckling/Duration/Types.hs @@ -18,7 +18,9 @@ import Control.DeepSeq import Data.Aeson import Data.Hashable +import Data.Semigroup import Data.Text (Text) +import Data.Tuple.Extra (both) import GHC.Generics import TextShow (showt) import Prelude @@ -34,8 +36,14 @@ instance Resolve DurationData where type ResolvedValue DurationData = DurationData - resolve _ x = Just x + resolve _ _ x = Just (x, False) +instance Semigroup DurationData where + d1@(DurationData _ g1) <> d2@(DurationData _ g2) = DurationData (v1+v2) g + where + g = g1 `min` g2 + (DurationData v1 _, DurationData v2 _) = both (withGrain g) (d1,d2) + instance ToJSON DurationData where toJSON DurationData {value, grain} = object [ "type" .= ("value" :: Text) @@ -47,3 +55,12 @@ , "value" .= inSeconds grain value ] ] + +-- | Convert a duration to the given grain, rounded to the +-- nearest integer. For example, 1 month is converted to 4 weeks. +withGrain :: Grain -> DurationData -> DurationData +withGrain g d@(DurationData v1 g1) + | g == g1 = d + | otherwise = DurationData v g + where + v = round $ inSeconds g1 (fromIntegral v1 :: Double) / inSeconds g 1 diff --git a/Duckling/Duration/ZH/Corpus.hs b/Duckling/Duration/ZH/Corpus.hs --- a/Duckling/Duration/ZH/Corpus.hs +++ b/Duckling/Duration/ZH/Corpus.hs @@ -22,7 +22,7 @@ import Duckling.TimeGrain.Types (Grain(..)) corpus :: Corpus -corpus = (testContext {locale = makeLocale ZH Nothing}, allExamples) +corpus = (testContext {locale = makeLocale ZH Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Email/Corpus.hs b/Duckling/Email/Corpus.hs --- a/Duckling/Email/Corpus.hs +++ b/Duckling/Email/Corpus.hs @@ -20,10 +20,10 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext, allExamples) +corpus = (testContext, testOptions, allExamples) negativeCorpus :: NegativeCorpus -negativeCorpus = (testContext, examples) +negativeCorpus = (testContext, testOptions, examples) where examples = [ "hey@6" diff --git a/Duckling/Email/EN/Corpus.hs b/Duckling/Email/EN/Corpus.hs --- a/Duckling/Email/EN/Corpus.hs +++ b/Duckling/Email/EN/Corpus.hs @@ -21,7 +21,7 @@ import Duckling.Testing.Types negativeCorpus :: NegativeCorpus -negativeCorpus = (testContext, examples) +negativeCorpus = (testContext, testOptions, examples) where examples = [ "fitness at 6.40" @@ -35,7 +35,7 @@ ] corpus :: Corpus -corpus = (testContext, allExamples) +corpus = (testContext, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Email/FR/Corpus.hs b/Duckling/Email/FR/Corpus.hs --- a/Duckling/Email/FR/Corpus.hs +++ b/Duckling/Email/FR/Corpus.hs @@ -21,7 +21,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale FR Nothing}, allExamples) +corpus = (testContext {locale = makeLocale FR Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Email/IT/Corpus.hs b/Duckling/Email/IT/Corpus.hs --- a/Duckling/Email/IT/Corpus.hs +++ b/Duckling/Email/IT/Corpus.hs @@ -21,7 +21,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale IT Nothing}, allExamples) +corpus = (testContext {locale = makeLocale IT Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Email/Types.hs b/Duckling/Email/Types.hs --- a/Duckling/Email/Types.hs +++ b/Duckling/Email/Types.hs @@ -29,7 +29,7 @@ instance Resolve EmailData where type ResolvedValue EmailData = EmailData - resolve _ x = Just x + resolve _ _ x = Just (x, False) instance ToJSON EmailData where toJSON EmailData {value} = object [ "value" .= value ] diff --git a/Duckling/Engine.hs b/Duckling/Engine.hs --- a/Duckling/Engine.hs +++ b/Duckling/Engine.hs @@ -19,7 +19,7 @@ import Control.DeepSeq import Control.Monad.Extra -import Data.Aeson +import Data.Aeson (toJSON) import Data.ByteString (ByteString) import Data.Functor.Identity import Data.Maybe @@ -48,10 +48,10 @@ runDuckling :: Duckling a -> a runDuckling ma = runIdentity ma -parseAndResolve :: [Rule] -> Text -> Context -> [ResolvedToken] -parseAndResolve rules input context = mapMaybe (resolveNode context) . - force $ Stash.toPosOrderedList $ runDuckling $ - parseString rules (Document.fromText input) +parseAndResolve :: [Rule] -> Text -> Context -> Options -> [ResolvedToken] +parseAndResolve rules input context options = + mapMaybe (resolveNode context options) . force $ Stash.toPosOrderedList $ + runDuckling $ parseString rules (Document.fromText input) produce :: Match -> Maybe Node produce (_, _, []) = Nothing @@ -218,11 +218,13 @@ headPredicateRules = [ rule | rule@Rule{pattern = (Predicate _ : _)} <- rules ] -resolveNode :: Context -> Node -> Maybe ResolvedToken -resolveNode context n@Node{token = (Token _ dd), nodeRange = nodeRange} = do - val <- resolve context dd +resolveNode :: Context -> Options -> Node -> Maybe ResolvedToken +resolveNode context options n@Node{token = (Token _ dd), nodeRange = nodeRange} + = do + (val, latent) <- resolve context options dd Just Resolved { range = nodeRange , node = n , jsonValue = toJSON val + , isLatent = latent } diff --git a/Duckling/Locale.hs b/Duckling/Locale.hs --- a/Duckling/Locale.hs +++ b/Duckling/Locale.hs @@ -60,6 +60,7 @@ | RO | RU | SV + | TA | TR | UK | VI diff --git a/Duckling/Numeral/AR/Corpus.hs b/Duckling/Numeral/AR/Corpus.hs --- a/Duckling/Numeral/AR/Corpus.hs +++ b/Duckling/Numeral/AR/Corpus.hs @@ -21,7 +21,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale AR Nothing}, allExamples) +corpus = (testContext {locale = makeLocale AR Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Numeral/AR/Rules.hs b/Duckling/Numeral/AR/Rules.hs --- a/Duckling/Numeral/AR/Rules.hs +++ b/Duckling/Numeral/AR/Rules.hs @@ -310,7 +310,7 @@ , pattern = [ dimension Numeral , regex "فاصل[ةه]" - , numberWith TNumeral.grain isNothing + , Predicate $ not . hasGrain ] , prod = \tokens -> case tokens of (Token Numeral NumeralData{TNumeral.value = v1}: diff --git a/Duckling/Numeral/BG/Corpus.hs b/Duckling/Numeral/BG/Corpus.hs --- a/Duckling/Numeral/BG/Corpus.hs +++ b/Duckling/Numeral/BG/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale BG Nothing}, allExamples) +corpus = (testContext {locale = makeLocale BG Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Numeral/BG/Rules.hs b/Duckling/Numeral/BG/Rules.hs --- a/Duckling/Numeral/BG/Rules.hs +++ b/Duckling/Numeral/BG/Rules.hs @@ -16,7 +16,6 @@ import Data.HashMap.Strict (HashMap) import Data.Maybe -import Data.String import Data.Text (Text) import Prelude import qualified Data.HashMap.Strict as HashMap @@ -164,7 +163,7 @@ , pattern = [ dimension Numeral , regex "цяло и" - , numberWith TNumeral.grain isNothing + , Predicate $ not . hasGrain ] , prod = \tokens -> case tokens of (Token Numeral nd1:_:Token Numeral nd2:_) -> diff --git a/Duckling/Numeral/CS/Corpus.hs b/Duckling/Numeral/CS/Corpus.hs --- a/Duckling/Numeral/CS/Corpus.hs +++ b/Duckling/Numeral/CS/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale CS Nothing}, allExamples) +corpus = (testContext {locale = makeLocale CS Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Numeral/DA/Corpus.hs b/Duckling/Numeral/DA/Corpus.hs --- a/Duckling/Numeral/DA/Corpus.hs +++ b/Duckling/Numeral/DA/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale DA Nothing}, allExamples) +corpus = (testContext {locale = makeLocale DA Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Numeral/DA/Rules.hs b/Duckling/Numeral/DA/Rules.hs --- a/Duckling/Numeral/DA/Rules.hs +++ b/Duckling/Numeral/DA/Rules.hs @@ -110,7 +110,7 @@ ruleIntersect = Rule { name = "intersect" , pattern = - [ numberWith (fromMaybe 0 . TNumeral.grain) (>1) + [ Predicate hasGrain , Predicate $ and . sequence [not . isMultipliable, isPositive] ] , prod = \tokens -> case tokens of @@ -269,7 +269,7 @@ , pattern = [ dimension Numeral , regex "komma" - , numberWith TNumeral.grain isNothing + , Predicate $ not . hasGrain ] , prod = \tokens -> case tokens of (Token Numeral NumeralData{TNumeral.value = v1}: diff --git a/Duckling/Numeral/DE/Corpus.hs b/Duckling/Numeral/DE/Corpus.hs --- a/Duckling/Numeral/DE/Corpus.hs +++ b/Duckling/Numeral/DE/Corpus.hs @@ -21,7 +21,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale DE Nothing}, allExamples) +corpus = (testContext {locale = makeLocale DE Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Numeral/DE/Rules.hs b/Duckling/Numeral/DE/Rules.hs --- a/Duckling/Numeral/DE/Rules.hs +++ b/Duckling/Numeral/DE/Rules.hs @@ -151,7 +151,7 @@ ruleIntersect = Rule { name = "intersect" , pattern = - [ numberWith (fromMaybe 0 . TNumeral.grain) (>1) + [ Predicate hasGrain , Predicate $ and . sequence [not . isMultipliable, isPositive] ] , prod = \tokens -> case tokens of @@ -294,7 +294,7 @@ , pattern = [ dimension Numeral , regex "komma" - , numberWith TNumeral.grain isNothing + , Predicate $ not . hasGrain ] , prod = \tokens -> case tokens of (Token Numeral NumeralData{TNumeral.value = v1}: diff --git a/Duckling/Numeral/EL/Corpus.hs b/Duckling/Numeral/EL/Corpus.hs --- a/Duckling/Numeral/EL/Corpus.hs +++ b/Duckling/Numeral/EL/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale EL Nothing}, allExamples) +corpus = (testContext {locale = makeLocale EL Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Numeral/EL/Rules.hs b/Duckling/Numeral/EL/Rules.hs --- a/Duckling/Numeral/EL/Rules.hs +++ b/Duckling/Numeral/EL/Rules.hs @@ -190,7 +190,7 @@ ruleSum = Rule { name = "intersect 2 numbers" , pattern = - [ numberWith (fromMaybe 0 . TNumeral.grain) (>1) + [ Predicate hasGrain , Predicate $ and . sequence [not . isMultipliable, isPositive] ] , prod = \tokens -> case tokens of @@ -230,7 +230,7 @@ , pattern = [ dimension Numeral , regex "κόμμα" - , numberWith TNumeral.grain isNothing + , Predicate $ not . hasGrain ] , prod = \tokens -> case tokens of (Token Numeral nd1:_:Token Numeral nd2:_) -> diff --git a/Duckling/Numeral/EN/Corpus.hs b/Duckling/Numeral/EN/Corpus.hs --- a/Duckling/Numeral/EN/Corpus.hs +++ b/Duckling/Numeral/EN/Corpus.hs @@ -18,7 +18,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext, allExamples) +corpus = (testContext, testOptions, allExamples) allExamples :: [Example] allExamples = concat @@ -126,6 +126,10 @@ , examples (NumeralValue 5000) [ "5 thousand" , "five thousand" + ] + , examples (NumeralValue (-504)) + [ "-504" + , "negative five hundred and four" ] , examples (NumeralValue (-1.2e6)) [ "- 1,200,000" diff --git a/Duckling/Numeral/EN/Rules.hs b/Duckling/Numeral/EN/Rules.hs --- a/Duckling/Numeral/EN/Rules.hs +++ b/Duckling/Numeral/EN/Rules.hs @@ -205,7 +205,7 @@ , pattern = [ dimension Numeral , regex "point|dot" - , numberWith TNumeral.grain isNothing + , Predicate $ not . hasGrain ] , prod = \tokens -> case tokens of (Token Numeral nd1:_:Token Numeral nd2:_) -> @@ -218,7 +218,7 @@ { name = "point 77" , pattern = [ regex "point|dot" - , numberWith TNumeral.grain isNothing + , Predicate $ not . hasGrain ] , prod = \tokens -> case tokens of (_:Token Numeral nd:_) -> double . decimalsToDouble $ TNumeral.value nd @@ -282,7 +282,7 @@ ruleSum = Rule { name = "intersect 2 numbers" , pattern = - [ numberWith (fromMaybe 0 . TNumeral.grain) (>1) + [ Predicate $ and . sequence [hasGrain, isPositive] , Predicate $ and . sequence [not . isMultipliable, isPositive] ] , prod = \tokens -> case tokens of @@ -296,7 +296,7 @@ ruleSumAnd = Rule { name = "intersect 2 numbers (with and)" , pattern = - [ numberWith (fromMaybe 0 . TNumeral.grain) (>1) + [ Predicate $ and . sequence [hasGrain, isPositive] , regex "and" , Predicate $ and . sequence [not . isMultipliable, isPositive] ] diff --git a/Duckling/Numeral/ES/Corpus.hs b/Duckling/Numeral/ES/Corpus.hs --- a/Duckling/Numeral/ES/Corpus.hs +++ b/Duckling/Numeral/ES/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale ES Nothing}, allExamples) +corpus = (testContext {locale = makeLocale ES Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Numeral/ES/Rules.hs b/Duckling/Numeral/ES/Rules.hs --- a/Duckling/Numeral/ES/Rules.hs +++ b/Duckling/Numeral/ES/Rules.hs @@ -260,7 +260,7 @@ , pattern = [ dimension Numeral , regex "punto" - , numberWith TNumeral.grain isNothing + , Predicate $ not . hasGrain ] , prod = \tokens -> case tokens of (Token Numeral NumeralData{TNumeral.value = v1}: diff --git a/Duckling/Numeral/ET/Corpus.hs b/Duckling/Numeral/ET/Corpus.hs --- a/Duckling/Numeral/ET/Corpus.hs +++ b/Duckling/Numeral/ET/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale ET Nothing}, allExamples) +corpus = (testContext {locale = makeLocale ET Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Numeral/ET/Rules.hs b/Duckling/Numeral/ET/Rules.hs --- a/Duckling/Numeral/ET/Rules.hs +++ b/Duckling/Numeral/ET/Rules.hs @@ -121,7 +121,7 @@ ruleIntersect = Rule { name = "intersect" , pattern = - [ numberWith (fromMaybe 0 . TNumeral.grain) (>1) + [ Predicate hasGrain , Predicate $ and . sequence [not . isMultipliable, isPositive] ] , prod = \tokens -> case tokens of @@ -247,7 +247,7 @@ , pattern = [ dimension Numeral , regex "dot|point" - , numberWith TNumeral.grain isNothing + , Predicate $ not . hasGrain ] , prod = \tokens -> case tokens of (Token Numeral NumeralData{TNumeral.value = v1}: diff --git a/Duckling/Numeral/FR/Corpus.hs b/Duckling/Numeral/FR/Corpus.hs --- a/Duckling/Numeral/FR/Corpus.hs +++ b/Duckling/Numeral/FR/Corpus.hs @@ -21,7 +21,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale FR Nothing}, allExamples) +corpus = (testContext {locale = makeLocale FR Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Numeral/FR/Rules.hs b/Duckling/Numeral/FR/Rules.hs --- a/Duckling/Numeral/FR/Rules.hs +++ b/Duckling/Numeral/FR/Rules.hs @@ -270,7 +270,7 @@ ruleSum = Rule { name = "intersect 2 numbers" , pattern = - [ numberWith (fromMaybe 0 . TNumeral.grain) (>1) + [ Predicate hasGrain , Predicate $ and . sequence [not . isMultipliable, isPositive] ] , prod = \tokens -> case tokens of diff --git a/Duckling/Numeral/GA/Corpus.hs b/Duckling/Numeral/GA/Corpus.hs --- a/Duckling/Numeral/GA/Corpus.hs +++ b/Duckling/Numeral/GA/Corpus.hs @@ -21,7 +21,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale GA Nothing}, allExamples) +corpus = (testContext {locale = makeLocale GA Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Numeral/HE/Corpus.hs b/Duckling/Numeral/HE/Corpus.hs --- a/Duckling/Numeral/HE/Corpus.hs +++ b/Duckling/Numeral/HE/Corpus.hs @@ -19,7 +19,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale HE Nothing}, allExamples) +corpus = (testContext {locale = makeLocale HE Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Numeral/HE/Rules.hs b/Duckling/Numeral/HE/Rules.hs --- a/Duckling/Numeral/HE/Rules.hs +++ b/Duckling/Numeral/HE/Rules.hs @@ -38,7 +38,7 @@ ruleIntersectNumerals = Rule { name = "intersect numbers" , pattern = - [ numberWith (fromMaybe 0 . TNumeral.grain) (>1) + [ Predicate hasGrain , Predicate $ and . sequence [not . isMultipliable, isPositive] ] , prod = \tokens -> case tokens of @@ -52,7 +52,7 @@ ruleIntersectWithAnd = Rule { name = "intersect (with and)" , pattern = - [ numberWith (fromMaybe 0 . TNumeral.grain) (>1) + [ Predicate hasGrain , regex "ו" , Predicate isMultipliable ] @@ -324,7 +324,7 @@ , pattern = [ dimension Numeral , regex "נקודה" - , numberWith TNumeral.grain isNothing + , Predicate $ not . hasGrain ] , prod = \tokens -> case tokens of (Token Numeral nd1:_:Token Numeral nd2:_) -> diff --git a/Duckling/Numeral/HI/Corpus.hs b/Duckling/Numeral/HI/Corpus.hs --- a/Duckling/Numeral/HI/Corpus.hs +++ b/Duckling/Numeral/HI/Corpus.hs @@ -21,7 +21,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale HI Nothing}, allExamples) +corpus = (testContext {locale = makeLocale HI Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Numeral/HR/Corpus.hs b/Duckling/Numeral/HR/Corpus.hs --- a/Duckling/Numeral/HR/Corpus.hs +++ b/Duckling/Numeral/HR/Corpus.hs @@ -19,7 +19,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale HR Nothing}, allExamples) +corpus = (testContext {locale = makeLocale HR Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Numeral/HR/Rules.hs b/Duckling/Numeral/HR/Rules.hs --- a/Duckling/Numeral/HR/Rules.hs +++ b/Duckling/Numeral/HR/Rules.hs @@ -158,7 +158,7 @@ ruleSum = Rule { name = "intersect" , pattern = - [ numberWith (fromMaybe 0 . TNumeral.grain) (>1) + [ Predicate hasGrain , Predicate $ and . sequence [not . isMultipliable, isPositive] ] , prod = \tokens -> case tokens of @@ -309,7 +309,7 @@ , pattern = [ dimension Numeral , regex "cijela|to(c|č)ka|zarez" - , numberWith TNumeral.grain isNothing + , Predicate $ not . hasGrain ] , prod = \tokens -> case tokens of (Token Numeral NumeralData{TNumeral.value = v1}: diff --git a/Duckling/Numeral/HU/Corpus.hs b/Duckling/Numeral/HU/Corpus.hs --- a/Duckling/Numeral/HU/Corpus.hs +++ b/Duckling/Numeral/HU/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale HU Nothing}, allExamples) +corpus = (testContext {locale = makeLocale HU Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Numeral/Helpers.hs b/Duckling/Numeral/Helpers.hs --- a/Duckling/Numeral/Helpers.hs +++ b/Duckling/Numeral/Helpers.hs @@ -11,12 +11,14 @@ module Duckling.Numeral.Helpers ( decimalsToDouble + , diffIntegerDigits , double , integer , multiply , isMultipliable , isNatural , isPositive + , hasGrain , divide , notOkForAnyTime , numberBetween @@ -79,6 +81,18 @@ [] -> 0 (multiplier : _) -> x / multiplier +-- diffIntegerDigits a b = # of digits in a - # of digits in b +-- ignores the nondecimal components +diffIntegerDigits :: Double -> Double -> Int +diffIntegerDigits a b = digitsOf a - digitsOf b + where + digitsOf :: Double -> Int + digitsOf = digitsOfInt . floor . abs + + digitsOfInt :: Int -> Int + digitsOfInt 0 = 0 + digitsOfInt a = 1 + digitsOfInt (a `div` 10) + -- ----------------------------------------------------------------- -- Patterns @@ -107,6 +121,10 @@ isMultipliable :: Predicate isMultipliable (Token Numeral nd) = multipliable nd isMultipliable _ = False + +hasGrain :: Predicate +hasGrain (Token Numeral NumeralData {grain = Just g}) = g > 1 +hasGrain _ = False oneOf :: [Double] -> PatternItem oneOf vs = Predicate $ \x -> diff --git a/Duckling/Numeral/ID/Corpus.hs b/Duckling/Numeral/ID/Corpus.hs --- a/Duckling/Numeral/ID/Corpus.hs +++ b/Duckling/Numeral/ID/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale ID Nothing}, allExamples) +corpus = (testContext {locale = makeLocale ID Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Numeral/ID/Rules.hs b/Duckling/Numeral/ID/Rules.hs --- a/Duckling/Numeral/ID/Rules.hs +++ b/Duckling/Numeral/ID/Rules.hs @@ -62,7 +62,7 @@ , pattern = [ dimension Numeral , regex "koma" - , numberWith TNumeral.grain isNothing + , Predicate $ not . hasGrain ] , prod = \tokens -> case tokens of (Token Numeral nd1:_:Token Numeral nd2:_) -> @@ -146,7 +146,7 @@ ruleIntersect = Rule { name = "intersect" , pattern = - [ numberWith (fromMaybe 0 . TNumeral.grain) (>1) + [ Predicate hasGrain , Predicate $ and . sequence [not . isMultipliable, isPositive] ] , prod = \tokens -> case tokens of diff --git a/Duckling/Numeral/IT/Corpus.hs b/Duckling/Numeral/IT/Corpus.hs --- a/Duckling/Numeral/IT/Corpus.hs +++ b/Duckling/Numeral/IT/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale IT Nothing}, allExamples) +corpus = (testContext {locale = makeLocale IT Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Numeral/JA/Corpus.hs b/Duckling/Numeral/JA/Corpus.hs --- a/Duckling/Numeral/JA/Corpus.hs +++ b/Duckling/Numeral/JA/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale JA Nothing}, allExamples) +corpus = (testContext {locale = makeLocale JA Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Numeral/KA/Corpus.hs b/Duckling/Numeral/KA/Corpus.hs --- a/Duckling/Numeral/KA/Corpus.hs +++ b/Duckling/Numeral/KA/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale KA Nothing}, allExamples) +corpus = (testContext {locale = makeLocale KA Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Numeral/KO/Corpus.hs b/Duckling/Numeral/KO/Corpus.hs --- a/Duckling/Numeral/KO/Corpus.hs +++ b/Duckling/Numeral/KO/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale KO Nothing}, allExamples) +corpus = (testContext {locale = makeLocale KO Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Numeral/KO/Rules.hs b/Duckling/Numeral/KO/Rules.hs --- a/Duckling/Numeral/KO/Rules.hs +++ b/Duckling/Numeral/KO/Rules.hs @@ -206,7 +206,7 @@ ruleSum = Rule { name = "intersect 2 numbers" , pattern = - [ numberWith (fromMaybe 0 . TNumeral.grain) (>1) + [ Predicate hasGrain , Predicate $ and . sequence [not . isMultipliable, isPositive] ] , prod = \tokens -> case tokens of diff --git a/Duckling/Numeral/MY/Corpus.hs b/Duckling/Numeral/MY/Corpus.hs --- a/Duckling/Numeral/MY/Corpus.hs +++ b/Duckling/Numeral/MY/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale MY Nothing}, allExamples) +corpus = (testContext {locale = makeLocale MY Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Numeral/NB/Corpus.hs b/Duckling/Numeral/NB/Corpus.hs --- a/Duckling/Numeral/NB/Corpus.hs +++ b/Duckling/Numeral/NB/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale NB Nothing}, allExamples) +corpus = (testContext {locale = makeLocale NB Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Numeral/NB/Rules.hs b/Duckling/Numeral/NB/Rules.hs --- a/Duckling/Numeral/NB/Rules.hs +++ b/Duckling/Numeral/NB/Rules.hs @@ -32,7 +32,7 @@ ruleIntersectWithAnd = Rule { name = "intersect (with and)" , pattern = - [ numberWith (fromMaybe 0 . TNumeral.grain) (>1) + [ Predicate hasGrain , regex "og" , Predicate $ and . sequence [not . isMultipliable, isPositive] ] @@ -129,7 +129,7 @@ ruleIntersect = Rule { name = "intersect" , pattern = - [ numberWith (fromMaybe 0 . TNumeral.grain) (>1) + [ Predicate hasGrain , Predicate $ and . sequence [not . isMultipliable, isPositive] ] , prod = \tokens -> case tokens of @@ -268,7 +268,7 @@ , pattern = [ dimension Numeral , regex "komma" - , numberWith TNumeral.grain isNothing + , Predicate $ not . hasGrain ] , prod = \tokens -> case tokens of (Token Numeral nd1:_:Token Numeral nd2:_) -> diff --git a/Duckling/Numeral/NE/Corpus.hs b/Duckling/Numeral/NE/Corpus.hs --- a/Duckling/Numeral/NE/Corpus.hs +++ b/Duckling/Numeral/NE/Corpus.hs @@ -21,7 +21,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale NE Nothing}, allExamples) +corpus = (testContext {locale = makeLocale NE Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Numeral/NL/Corpus.hs b/Duckling/Numeral/NL/Corpus.hs --- a/Duckling/Numeral/NL/Corpus.hs +++ b/Duckling/Numeral/NL/Corpus.hs @@ -21,7 +21,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale NL Nothing}, allExamples) +corpus = (testContext {locale = makeLocale NL Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Numeral/NL/Rules.hs b/Duckling/Numeral/NL/Rules.hs --- a/Duckling/Numeral/NL/Rules.hs +++ b/Duckling/Numeral/NL/Rules.hs @@ -115,7 +115,7 @@ ruleIntersect = Rule { name = "intersect" , pattern = - [ numberWith (fromMaybe 0 . TNumeral.grain) (>1) + [ Predicate hasGrain , Predicate $ and . sequence [not . isMultipliable, isPositive] ] , prod = \tokens -> case tokens of diff --git a/Duckling/Numeral/PL/Corpus.hs b/Duckling/Numeral/PL/Corpus.hs --- a/Duckling/Numeral/PL/Corpus.hs +++ b/Duckling/Numeral/PL/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale PL Nothing}, allExamples) +corpus = (testContext {locale = makeLocale PL Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Numeral/PL/Rules.hs b/Duckling/Numeral/PL/Rules.hs --- a/Duckling/Numeral/PL/Rules.hs +++ b/Duckling/Numeral/PL/Rules.hs @@ -65,7 +65,7 @@ ruleIntersectWithAnd = Rule { name = "intersect (with and)" , pattern = - [ numberWith (fromMaybe 0 . TNumeral.grain) (>1) + [ Predicate hasGrain , regex "i|a" , Predicate $ and . sequence [not . isMultipliable, isPositive] ] @@ -328,7 +328,7 @@ ruleIntersect = Rule { name = "intersect" , pattern = - [ numberWith (fromMaybe 0 . TNumeral.grain) (>1) + [ Predicate hasGrain , Predicate $ and . sequence [not . isMultipliable, isPositive] ] , prod = \tokens -> case tokens of @@ -514,7 +514,7 @@ , pattern = [ dimension Numeral , regex "dot|point" - , numberWith TNumeral.grain isNothing + , Predicate $ not . hasGrain ] , prod = \tokens -> case tokens of (Token Numeral nd1:_:Token Numeral nd2:_) -> diff --git a/Duckling/Numeral/PT/Corpus.hs b/Duckling/Numeral/PT/Corpus.hs --- a/Duckling/Numeral/PT/Corpus.hs +++ b/Duckling/Numeral/PT/Corpus.hs @@ -21,7 +21,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale PT Nothing}, allExamples) +corpus = (testContext {locale = makeLocale PT Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Numeral/PT/Rules.hs b/Duckling/Numeral/PT/Rules.hs --- a/Duckling/Numeral/PT/Rules.hs +++ b/Duckling/Numeral/PT/Rules.hs @@ -249,7 +249,7 @@ , pattern = [ dimension Numeral , regex "ponto" - , numberWith TNumeral.grain isNothing + , Predicate $ not . hasGrain ] , prod = \tokens -> case tokens of (Token Numeral nd1:_:Token Numeral nd2:_) -> @@ -262,7 +262,7 @@ { name = "point 77" , pattern = [ regex "ponto" - , numberWith TNumeral.grain isNothing + , Predicate $ not . hasGrain ] , prod = \tokens -> case tokens of (_:Token Numeral nd:_) -> double . decimalsToDouble $ TNumeral.value nd @@ -326,7 +326,7 @@ ruleSum = Rule { name = "intersect 2 numbers" , pattern = - [ numberWith (fromMaybe 0 . TNumeral.grain) (>1) + [ Predicate hasGrain , Predicate $ and . sequence [not . isMultipliable, isPositive] ] , prod = \tokens -> case tokens of @@ -340,7 +340,7 @@ ruleSumAnd = Rule { name = "intersect 2 numbers (with and)" , pattern = - [ numberWith (fromMaybe 0 . TNumeral.grain) (>1) + [ Predicate hasGrain , regex "e" , Predicate $ and . sequence [not . isMultipliable, isPositive] ] diff --git a/Duckling/Numeral/RO/Corpus.hs b/Duckling/Numeral/RO/Corpus.hs --- a/Duckling/Numeral/RO/Corpus.hs +++ b/Duckling/Numeral/RO/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale RO Nothing}, allExamples) +corpus = (testContext {locale = makeLocale RO Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Numeral/RO/Rules.hs b/Duckling/Numeral/RO/Rules.hs --- a/Duckling/Numeral/RO/Rules.hs +++ b/Duckling/Numeral/RO/Rules.hs @@ -109,7 +109,7 @@ ruleIntersect = Rule { name = "intersect" , pattern = - [ numberWith (fromMaybe 0 . TNumeral.grain) (>1) + [ Predicate hasGrain , Predicate $ and . sequence [not . isMultipliable, isPositive] ] , prod = \tokens -> case tokens of @@ -123,7 +123,7 @@ ruleIntersectCuI = Rule { name = "intersect (cu și)" , pattern = - [ numberWith (fromMaybe 0 . TNumeral.grain) (>1) + [ Predicate hasGrain , regex "(s|ș)i" , Predicate $ and . sequence [not . isMultipliable, isPositive] ] diff --git a/Duckling/Numeral/RU/Corpus.hs b/Duckling/Numeral/RU/Corpus.hs --- a/Duckling/Numeral/RU/Corpus.hs +++ b/Duckling/Numeral/RU/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale RU Nothing}, allExamples) +corpus = (testContext {locale = makeLocale RU Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Numeral/RU/Rules.hs b/Duckling/Numeral/RU/Rules.hs --- a/Duckling/Numeral/RU/Rules.hs +++ b/Duckling/Numeral/RU/Rules.hs @@ -248,7 +248,7 @@ , pattern = [ dimension Numeral , regex "точка" - , numberWith TNumeral.grain isNothing + , Predicate $ not . hasGrain ] , prod = \tokens -> case tokens of (Token Numeral nd1:_:Token Numeral nd2:_) -> diff --git a/Duckling/Numeral/SV/Corpus.hs b/Duckling/Numeral/SV/Corpus.hs --- a/Duckling/Numeral/SV/Corpus.hs +++ b/Duckling/Numeral/SV/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale SV Nothing}, allExamples) +corpus = (testContext {locale = makeLocale SV Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Numeral/SV/Rules.hs b/Duckling/Numeral/SV/Rules.hs --- a/Duckling/Numeral/SV/Rules.hs +++ b/Duckling/Numeral/SV/Rules.hs @@ -32,7 +32,7 @@ ruleIntersectWithAnd = Rule { name = "intersect (with and)" , pattern = - [ numberWith (fromMaybe 0 . TNumeral.grain) (>1) + [ Predicate hasGrain , regex "och" , Predicate $ and . sequence [not . isMultipliable, isPositive] ] @@ -119,7 +119,7 @@ ruleIntersect = Rule { name = "intersect" , pattern = - [ numberWith (fromMaybe 0 . TNumeral.grain) (>1) + [ Predicate hasGrain , Predicate $ and . sequence [not . isMultipliable, isPositive] ] , prod = \tokens -> case tokens of @@ -264,7 +264,7 @@ , pattern = [ dimension Numeral , regex "komma" - , numberWith TNumeral.grain isNothing + , Predicate $ not . hasGrain ] , prod = \tokens -> case tokens of (Token Numeral nd1:_:Token Numeral nd2:_) -> diff --git a/Duckling/Numeral/TA/Corpus.hs b/Duckling/Numeral/TA/Corpus.hs new file mode 100644 --- /dev/null +++ b/Duckling/Numeral/TA/Corpus.hs @@ -0,0 +1,88 @@ +-- Copyright (c) 2016-present, Facebook, Inc. +-- All rights reserved. +-- +-- This source code is licensed under the BSD-style license found in the +-- LICENSE file in the root directory of this source tree. An additional grant +-- of patent rights can be found in the PATENTS file in the same directory. + + +{-# LANGUAGE OverloadedStrings #-} + +module Duckling.Numeral.TA.Corpus + ( corpus + ) where + +import Data.String +import Prelude + +import Duckling.Locale +import Duckling.Numeral.Types +import Duckling.Resolve +import Duckling.Testing.Types + +corpus :: Corpus +corpus = (testContext {locale = makeLocale TA Nothing}, testOptions, allExamples) + +allExamples :: [Example] +allExamples = concat + [ examples (NumeralValue 0) + [ "பூஜ்ஜியம்" + ] + , examples (NumeralValue 1) + [ "ஒன்று" + ] + , examples (NumeralValue 2) + [ "இரண்டு" + ] + , examples (NumeralValue 3) + [ "மூன்று" + ] + , examples (NumeralValue 4) + [ "நான்கு" + ] + , examples (NumeralValue 5) + [ "ஐந்து" + ] + , examples (NumeralValue 6) + [ "ஆறு" + ] + , examples (NumeralValue 7) + [ "ஏழு" + ] + , examples (NumeralValue 8) + [ "எட்டு" + ] + , examples (NumeralValue 9) + [ "ஒன்பது" + ] + , examples (NumeralValue 10) + [ "பத்து" + ] + , examples (NumeralValue 11) + [ "பதினொன்று" + ] + , examples (NumeralValue 12) + [ "பன்னிரண்டு" + ] + , examples (NumeralValue 20) + [ "இருபது" + ] + , examples (NumeralValue 21) + [ "இருபத்திஒன்று" + ] + , examples (NumeralValue 22) + [ "இருபத்திஇரண்டு" + ] + , examples (NumeralValue 26) + [ "இருபத்திஆறு" + ] + , examples (NumeralValue 30) + [ "முப்பது" + ] + , examples (NumeralValue 33) + [ "முப்பத்துமூன்று" + ] + , examples (NumeralValue 50) + [ "ஐம்பது" + ] + ] diff --git a/Duckling/Numeral/TA/Rules.hs b/Duckling/Numeral/TA/Rules.hs new file mode 100644 --- /dev/null +++ b/Duckling/Numeral/TA/Rules.hs @@ -0,0 +1,137 @@ +-- Copyright (c) 2016-present, Facebook, Inc. +-- All rights reserved. +-- +-- This source code is licensed under the BSD-style license found in the +-- LICENSE file in the root directory of this source tree. An additional grant +-- of patent rights can be found in the PATENTS file in the same directory. + + +{-# LANGUAGE GADTs #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE NoRebindableSyntax #-} +{-# LANGUAGE LambdaCase #-} + +module Duckling.Numeral.TA.Rules + ( rules + ) where + +import Data.HashMap.Strict (HashMap) +import Data.Maybe +import Data.String +import Data.Text (Text) +import Prelude +import qualified Data.HashMap.Strict as HashMap +import qualified Data.Text as Text + +import Duckling.Dimensions.Types +import Duckling.Numeral.Helpers +import Duckling.Numeral.Types (NumeralData (..)) +import Duckling.Regex.Types +import Duckling.Types +import qualified Duckling.Numeral.Types as TNumeral + +zeroToNineMap :: HashMap Text Integer +zeroToNineMap = HashMap.fromList + [ ( "பூஜ்ஜியம்", 0 ) + , ( "ஒன்று", 1 ) + , ( "இரண்டு", 2 ) + , ( "மூன்று", 3 ) + , ( "நான்கு", 4 ) + , ( "ஐந்து", 5 ) + , ( "ஆறு", 6 ) + , ( "ஏழு", 7 ) + , ( "எட்டு", 8 ) + , ( "ஒன்பது", 9 ) + ] + +ruleZeroToNine :: Rule +ruleZeroToNine = Rule + { name = "integer (0..9)" + , pattern = + [ regex "(பூஜ்ஜியம்|ஒன்று|இரண்டு|மூன்று|நான்கு|ஐந்து|ஆறு|ஏழு|எட்டு|ஒன்பது)" + ] + , prod = \case + (Token RegexMatch (GroupMatch (match:_)):_) -> + HashMap.lookup (Text.toLower match) zeroToNineMap >>= integer + _ -> Nothing + } + +tenToNineteenMap :: HashMap Text Integer +tenToNineteenMap = HashMap.fromList + [ ( "பத்து", 10 ) + , ( "பதினொன்று", 11 ) + , ( "பன்னிரண்டு", 12 ) + , ( "பதின்மூன்று", 13 ) + , ( "பதினான்கு", 14 ) + , ( "பதினைந்து", 15 ) + , ( "பதினாறு", 16 ) + , ( "பதினேழு", 17 ) + , ( "பதினெட்டு", 18 ) + , ( "பத்தொன்பது", 19 ) + ] + +ruleTenToNineteen :: Rule +ruleTenToNineteen = Rule + { name = "integer (10..19)" + , pattern = + [ regex "(பத்து|பதினொன்று|பன்னிரண்டு|பதின்மூன்று|பதினான்கு|பதினைந்து|பதினாறு|பதினேழு|பதினெட்டு|பத்தொன்பது)" + ] + , prod = \case + (Token RegexMatch (GroupMatch (match:_)):_) -> + HashMap.lookup (Text.toLower match) tenToNineteenMap >>= integer + _ -> Nothing + } + +tensMap :: HashMap Text Integer +tensMap = HashMap.fromList + [ ( "இருபது", 20 ) + , ( "இருபத்தி", 20 ) + , ( "முப்பது", 30 ) + , ( "முப்பத்து", 30 ) + , ( "நாற்பது", 40 ) + , ( "நாற்பத்து", 40 ) + , ( "ஐம்பது", 50 ) + , ( "ஐம்பத்தி", 50 ) + , ( "அறுபது", 60 ) + , ( "அறுபத்", 60 ) + , ( "எழுபது", 70 ) + , ( "எழுபத்தி", 70 ) + , ( "எண்பது", 80 ) + , ( "எண்பத்", 80 ) + , ( "தொண்ணூறு", 90 ) + , ( "தொண்ணுற்று", 90 ) + ] + +ruleTens :: Rule +ruleTens = Rule + { name = "integer (20..90)" + , pattern = + [ regex "(இருபது|முப்பது|நாற்பது|ஐம்பது|அறுபது|எழுபது|எண்பது|தொண்ணூறு)" + ] + , prod = \case + (Token RegexMatch (GroupMatch (match:_)):_) -> + HashMap.lookup (Text.toLower match) tensMap >>= integer + _ -> Nothing + } + +ruleCompositeTens :: Rule +ruleCompositeTens = Rule + { name = "integer ([2-9][1-9])" + , pattern = + [ regex "(இருபத்தி|முப்பத்து|நாற்பத்து|ஐம்பத்தி|அறுபத்|எழுபத்தி|எண்பத்|தொண்ணுற்று)(ஒன்று|இரண்டு|மூன்று|நான்கு|ஐந்து|ஆறு|ஏழு|எட்டு|ஒன்பது)" + ] + , prod = \case + (Token RegexMatch (GroupMatch (m1:m2:_)):_) -> do + v1 <- HashMap.lookup (Text.toLower m1) tensMap + v2 <- HashMap.lookup (Text.toLower m2) zeroToNineMap + integer $ v1 + v2 + _ -> Nothing + } + +rules :: [Rule] +rules = + [ ruleZeroToNine + , ruleTenToNineteen + , ruleTens + , ruleCompositeTens + ] diff --git a/Duckling/Numeral/TR/Corpus.hs b/Duckling/Numeral/TR/Corpus.hs --- a/Duckling/Numeral/TR/Corpus.hs +++ b/Duckling/Numeral/TR/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale TR Nothing}, allExamples) +corpus = (testContext {locale = makeLocale TR Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Numeral/TR/Rules.hs b/Duckling/Numeral/TR/Rules.hs --- a/Duckling/Numeral/TR/Rules.hs +++ b/Duckling/Numeral/TR/Rules.hs @@ -305,7 +305,7 @@ ruleIntersect = Rule { name = "intersect" , pattern = - [ numberWith (fromMaybe 0 . TNumeral.grain) (>1) + [ Predicate hasGrain , Predicate $ and . sequence [not . isMultipliable, isPositive] ] , prod = \tokens -> case tokens of @@ -666,7 +666,7 @@ , pattern = [ dimension Numeral , regex "nokta|virgül" - , numberWith TNumeral.grain isNothing + , Predicate $ not . hasGrain ] , prod = \tokens -> case tokens of (Token Numeral NumeralData{TNumeral.value = v1}: diff --git a/Duckling/Numeral/Types.hs b/Duckling/Numeral/Types.hs --- a/Duckling/Numeral/Types.hs +++ b/Duckling/Numeral/Types.hs @@ -39,7 +39,7 @@ instance Resolve NumeralData where type ResolvedValue NumeralData = NumeralValue - resolve _ NumeralData {value} = Just NumeralValue {vValue = value} + resolve _ _ NumeralData {value} = Just (NumeralValue {vValue = value}, False) newtype NumeralValue = NumeralValue { vValue :: Double } deriving (Eq, Show) diff --git a/Duckling/Numeral/UK/Corpus.hs b/Duckling/Numeral/UK/Corpus.hs --- a/Duckling/Numeral/UK/Corpus.hs +++ b/Duckling/Numeral/UK/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale UK Nothing}, allExamples) +corpus = (testContext {locale = makeLocale UK Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Numeral/UK/Rules.hs b/Duckling/Numeral/UK/Rules.hs --- a/Duckling/Numeral/UK/Rules.hs +++ b/Duckling/Numeral/UK/Rules.hs @@ -225,7 +225,7 @@ , pattern = [ dimension Numeral , regex "крапка" - , numberWith TNumeral.grain isNothing + , Predicate $ not . hasGrain ] , prod = \tokens -> case tokens of (Token Numeral nd1:_:Token Numeral nd2:_) -> diff --git a/Duckling/Numeral/VI/Corpus.hs b/Duckling/Numeral/VI/Corpus.hs --- a/Duckling/Numeral/VI/Corpus.hs +++ b/Duckling/Numeral/VI/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale VI Nothing}, allExamples) +corpus = (testContext {locale = makeLocale VI Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat @@ -61,16 +61,16 @@ , "tră" ] , examples (NumeralValue 1.1) - [ "1.1" - , "1.10" - , "01.10" + [ "1,1" + , "1,10" + , "01,10" ] , examples (NumeralValue 0.77) - [ "0.77" - , ".77" + [ "0,77" + , ",77" ] , examples (NumeralValue 100000) - [ "100,000" + [ "100.000" , "100000" , "100K" , "100k" @@ -79,22 +79,22 @@ [ "3M" , "3000K" , "3000000" - , "3,000,000" + , "3.000.000" ] , examples (NumeralValue 1200000) - [ "1,200,000" + [ "1.200.000" , "1200000" - , "1.2M" + , "1,2M" , "1200K" - , ".0012G" + , ",0012G" ] , examples (NumeralValue (-1200000)) - [ "- 1,200,000" + [ "- 1.200.000" , "-1200000" - , "âm 1,200,000" - , "-1.2M" + , "âm 1.200.000" + , "-1,2M" , "-1200K" - , "-.0012G" + , "-,0012G" ] , examples (NumeralValue 5000) [ "5 nghìn" diff --git a/Duckling/Numeral/VI/Rules.hs b/Duckling/Numeral/VI/Rules.hs --- a/Duckling/Numeral/VI/Rules.hs +++ b/Duckling/Numeral/VI/Rules.hs @@ -79,11 +79,11 @@ ruleDecimalWithThousandsSeparator = Rule { name = "decimal with thousands separator" , pattern = - [ regex "(\\d+(,\\d\\d\\d)+\\.\\d+)" + [ regex "(\\d+(\\.\\d\\d\\d)+,\\d+)" ] , prod = \tokens -> case tokens of (Token RegexMatch (GroupMatch (match:_)):_) -> - parseDouble (Text.replace "," Text.empty match) >>= double + parseDouble (Text.replace "." Text.empty match) >>= double _ -> Nothing } @@ -91,10 +91,10 @@ ruleDecimalNumeral = Rule { name = "decimal number" , pattern = - [ regex "(\\d*\\.\\d+)" + [ regex "(\\d*,\\d+)" ] , prod = \tokens -> case tokens of - (Token RegexMatch (GroupMatch (match:_)):_) -> parseDecimal True match + (Token RegexMatch (GroupMatch (match:_)):_) -> parseDecimal False match _ -> Nothing } @@ -118,7 +118,7 @@ , pattern = [ dimension Numeral , regex "chấm|phẩy" - , numberWith TNumeral.grain isNothing + , Predicate $ not . hasGrain ] , prod = \tokens -> case tokens of (Token Numeral nd1:_:Token Numeral nd2:_) -> @@ -130,7 +130,7 @@ ruleIntersect = Rule { name = "intersect" , pattern = - [ numberWith (fromMaybe 0 . TNumeral.grain) (>1) + [ Predicate hasGrain , Predicate $ and . sequence [not . isMultipliable, isPositive] ] , prod = \tokens -> case tokens of @@ -275,11 +275,11 @@ ruleIntegerWithThousandsSeparator = Rule { name = "integer with thousands separator ," , pattern = - [ regex "(\\d{1,3}(,\\d\\d\\d){1,5})" + [ regex "(\\d{1,3}(\\.\\d\\d\\d){1,5})" ] , prod = \tokens -> case tokens of (Token RegexMatch (GroupMatch (match:_)): - _) -> let fmt = Text.replace "," Text.empty match + _) -> let fmt = Text.replace "." Text.empty match in parseDouble fmt >>= double _ -> Nothing } diff --git a/Duckling/Numeral/ZH/Corpus.hs b/Duckling/Numeral/ZH/Corpus.hs --- a/Duckling/Numeral/ZH/Corpus.hs +++ b/Duckling/Numeral/ZH/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale ZH Nothing}, allExamples) +corpus = (testContext {locale = makeLocale ZH Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat @@ -66,6 +66,24 @@ [ "96" , "九十六" ] + , examples (NumeralValue 203) + [ "203" + , "二百零三" + ] + , examples (NumeralValue 534) + [ "534" + , "五百三十四" + ] + , examples (NumeralValue 34567) + [ "34567" + , "34,567" + , "三万四千五百六十七" + ] + , examples (NumeralValue 10040) + [ "10040" + , "10,040" + , "一万零四十" + ] , examples (NumeralValue 1.1) [ "1.1" , "1.10" @@ -75,24 +93,36 @@ [ "0.77" , ".77" ] + , examples (NumeralValue 34507) + [ "34507" + , "34,507" + , "三万四千五百零七" + ] , examples (NumeralValue 100000) [ "100,000" , "100000" , "100K" , "100k" + , "十万" ] , examples (NumeralValue 3000000) [ "3M" - , "3000K" , "3000000" , "3,000,000" + , "三百万" ] + , examples (NumeralValue 1040000) + [ "1,040,000" + , "1040000" + , "1.04M" + , "一百零四万" + ] , examples (NumeralValue 1200000) [ "1,200,000" , "1200000" , "1.2M" - , "1200K" , ".0012G" + , "一百二十万" ] , examples (NumeralValue (-1200000)) [ "- 1,200,000" @@ -105,5 +135,6 @@ , "-1.2M" , "-1200K" , "-.0012G" + , "负一百二十万" ] ] diff --git a/Duckling/Numeral/ZH/Rules.hs b/Duckling/Numeral/ZH/Rules.hs --- a/Duckling/Numeral/ZH/Rules.hs +++ b/Duckling/Numeral/ZH/Rules.hs @@ -7,6 +7,7 @@ {-# LANGUAGE GADTs #-} +{-# LANGUAGE LambdaCase #-} {-# LANGUAGE OverloadedStrings #-} module Duckling.Numeral.ZH.Rules @@ -15,6 +16,7 @@ import Data.Maybe import Data.String +import Data.Text (Text) import Prelude import qualified Data.HashMap.Strict as HashMap import qualified Data.Text as Text @@ -26,19 +28,19 @@ import Duckling.Types import qualified Duckling.Numeral.Types as TNumeral -ruleInteger5 :: Rule -ruleInteger5 = Rule +ruleInteger :: Rule +ruleInteger = Rule { name = "integer (0..10)" , pattern = - [ regex "(〇|零|一|二|两|兩|三|四|五|六|七|八|九|十)(个|個)?" + [ regex "(〇|零|一|二|两|兩|三|四|五|六|七|八|九|十)" ] - , prod = \tokens -> case tokens of + , prod = \case (Token RegexMatch (GroupMatch (match:_)):_) -> HashMap.lookup match integerMap >>= integer _ -> Nothing } -integerMap :: HashMap.HashMap Text.Text Integer +integerMap :: HashMap.HashMap Text Integer integerMap = HashMap.fromList [ ( "〇", 0 ) , ( "零", 0 ) @@ -64,7 +66,7 @@ [ regex "-|负|負" , Predicate isPositive ] - , prod = \tokens -> case tokens of + , prod = \case (_:Token Numeral nd:_) -> double (TNumeral.value nd * (-1)) _ -> Nothing } @@ -75,7 +77,7 @@ , pattern = [ regex "(\\d+(,\\d\\d\\d)+\\.\\d+)" ] - , prod = \tokens -> case tokens of + , prod = \case (Token RegexMatch (GroupMatch (match:_)):_) -> parseDouble (Text.replace "," Text.empty match) >>= double _ -> Nothing @@ -87,102 +89,124 @@ , pattern = [ regex "(\\d*\\.\\d+)" ] - , prod = \tokens -> case tokens of + , prod = \case (Token RegexMatch (GroupMatch (match:_)):_) -> parseDecimal True match _ -> Nothing } ruleNumeral :: Rule ruleNumeral = Rule - { name = "个" + { name = "个/個" , pattern = [ dimension Numeral - , regex "个" + , regex "个|個" ] - , prod = \tokens -> case tokens of + , prod = \case (token:_) -> Just token _ -> Nothing } -ruleInteger3 :: Rule -ruleInteger3 = Rule - { name = "integer (20..90)" - , pattern = - [ numberBetween 2 10 - , regex "十" - ] - , prod = \tokens -> case tokens of - (Token Numeral NumeralData{TNumeral.value = v}:_) -> double $ v * 10 - _ -> Nothing - } +numeralSuffixList :: [(Text, Maybe Token)] +numeralSuffixList = + [ ("K", double 1e3 >>= withGrain 3 >>= withMultipliable) + , ("M", double 1e6 >>= withGrain 6 >>= withMultipliable) + , ("G", double 1e9 >>= withGrain 9 >>= withMultipliable) + , ("十", double 1e1 >>= withGrain 1 >>= withMultipliable) + , ("百", double 1e2 >>= withGrain 2 >>= withMultipliable) + , ("千", double 1e3 >>= withGrain 3 >>= withMultipliable) + , ("万", double 1e4 >>= withGrain 4 >>= withMultipliable) + , ("亿", double 1e8 >>= withGrain 8 >>= withMultipliable) + ] -ruleNumeralsSuffixesKMG :: Rule -ruleNumeralsSuffixesKMG = Rule - { name = "numbers suffixes (K, M, G)" +ruleNumeralSuffixes :: [Rule] +ruleNumeralSuffixes = uncurry constructNumeralSuffixRule <$> numeralSuffixList + where + constructNumeralSuffixRule :: Text -> Maybe Token -> Rule + constructNumeralSuffixRule suffixName production = Rule + { name = "number suffix: " `mappend` suffixName + , pattern = + [ regex $ Text.unpack suffixName + ] + , prod = const production + } + + +ruleMultiply :: Rule +ruleMultiply = Rule + { name = "compose by multiplication" , pattern = [ dimension Numeral - , regex "([kmg])" + , Predicate isMultipliable ] - , prod = \tokens -> case tokens of - (Token Numeral NumeralData{TNumeral.value = v}: - Token RegexMatch (GroupMatch (match:_)): - _) -> case Text.toLower match of - "k" -> double $ v * 1e3 - "m" -> double $ v * 1e6 - "g" -> double $ v * 1e9 - _ -> Nothing + , prod = \case + (token1:token2:_) -> multiply token1 token2 _ -> Nothing } -ruleInteger4 :: Rule -ruleInteger4 = Rule - { name = "integer 21..99" +ruleIntegerWithThousandsSeparator :: Rule +ruleIntegerWithThousandsSeparator = Rule + { name = "integer with thousands separator ," , pattern = - [ oneOf [70, 20, 60, 50, 40, 90, 30, 80] - , numberBetween 1 10 + [ regex "(\\d{1,3}(,\\d\\d\\d){1,5})" ] - , prod = \tokens -> case tokens of - (Token Numeral NumeralData{TNumeral.value = v1}: - Token Numeral NumeralData{TNumeral.value = v2}: - _) -> double $ v1 + v2 + , prod = \case + (Token RegexMatch (GroupMatch (match:_)): + _) -> let fmt = Text.replace "," Text.empty match + in parseDouble fmt >>= double _ -> Nothing } -ruleInteger2 :: Rule -ruleInteger2 = Rule - { name = "integer (11..19)" +ruleNumeralsIntersectNonconsectiveUnit :: Rule +ruleNumeralsIntersectNonconsectiveUnit = Rule + { name = "integer with nonconsecutive unit modifiers" , pattern = - [ regex "十" - , numberBetween 1 10 + [ Predicate isPositive + , regex "零|〇" + , Predicate isPositive ] - , prod = \tokens -> case tokens of - (_:Token Numeral NumeralData{TNumeral.value = v}:_) -> double $ 10 + v + , prod = \case + (Token Numeral NumeralData{TNumeral.value = v1}:_: + Token Numeral NumeralData{TNumeral.value = v2}:_) -> + sumConnectedNumbers v1 v2 (diffIntegerDigits v1 v2) + >>= double _ -> Nothing } + where + sumConnectedNumbers :: Double -> Double -> Int -> Maybe Double + sumConnectedNumbers v1 v2 d + | d <= 1 = Nothing + | otherwise = Just $ v1 + v2 -ruleIntegerWithThousandsSeparator :: Rule -ruleIntegerWithThousandsSeparator = Rule - { name = "integer with thousands separator ," +ruleNumeralsIntersectConsecutiveUnit :: Rule +ruleNumeralsIntersectConsecutiveUnit = Rule + { name = "integer with consecutive unit modifiers" , pattern = - [ regex "(\\d{1,3}(,\\d\\d\\d){1,5})" + [ Predicate isPositive + , Predicate isPositive ] - , prod = \tokens -> case tokens of - (Token RegexMatch (GroupMatch (match:_)): - _) -> let fmt = Text.replace "," Text.empty match - in parseDouble fmt >>= double + , prod = \case + (Token Numeral NumeralData{TNumeral.value = v1}: + Token Numeral NumeralData{TNumeral.value = v2}:_) -> + sumConnectedNumbers v1 v2 (diffIntegerDigits v1 v2) + >>= double _ -> Nothing } + where + sumConnectedNumbers :: Double -> Double -> Int -> Maybe Double + sumConnectedNumbers v1 v2 d + | d == 1 = Just $ v1 + v2 + | otherwise = Nothing rules :: [Rule] rules = [ ruleDecimalNumeral , ruleDecimalWithThousandsSeparator - , ruleInteger2 - , ruleInteger3 - , ruleInteger4 - , ruleInteger5 + , ruleInteger , ruleIntegerWithThousandsSeparator , ruleNumeral + , ruleNumeralsIntersectConsecutiveUnit + , ruleNumeralsIntersectNonconsectiveUnit , ruleNumeralsPrefixWithNegativeOrMinus - , ruleNumeralsSuffixesKMG + , ruleMultiply ] + ++ ruleNumeralSuffixes diff --git a/Duckling/Ordinal/AR/Corpus.hs b/Duckling/Ordinal/AR/Corpus.hs --- a/Duckling/Ordinal/AR/Corpus.hs +++ b/Duckling/Ordinal/AR/Corpus.hs @@ -21,7 +21,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale AR Nothing}, allExamples) +corpus = (testContext {locale = makeLocale AR Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Ordinal/AR/Rules.hs b/Duckling/Ordinal/AR/Rules.hs --- a/Duckling/Ordinal/AR/Rules.hs +++ b/Duckling/Ordinal/AR/Rules.hs @@ -15,7 +15,6 @@ ) where import Data.HashMap.Strict (HashMap) -import Data.String import Data.Text (Text) import Prelude import qualified Data.Text as Text diff --git a/Duckling/Ordinal/BG/Corpus.hs b/Duckling/Ordinal/BG/Corpus.hs new file mode 100644 --- /dev/null +++ b/Duckling/Ordinal/BG/Corpus.hs @@ -0,0 +1,262 @@ +-- Copyright (c) 2016-present, Facebook, Inc. +-- All rights reserved. +-- +-- This source code is licensed under the BSD-style license found in the +-- LICENSE file in the root directory of this source tree. An additional grant +-- of patent rights can be found in the PATENTS file in the same directory. + + +{-# LANGUAGE OverloadedStrings #-} + +module Duckling.Ordinal.BG.Corpus + ( corpus + ) where + +import Data.String +import Prelude + +import Duckling.Locale +import Duckling.Ordinal.Types +import Duckling.Resolve +import Duckling.Testing.Types + +corpus :: Corpus +corpus = (testContext {locale = makeLocale BG Nothing}, testOptions, allExamples) + +allExamples :: [Example] +allExamples = concat + [ examples (OrdinalData 1) + [ "първи" + , "първите" + , "първия" + , "първият" + , "първо" + , "първото" + , "първа" + , "първата" + , "1ви" + , "1-ви" + , "1вите" + , "1-вите" + , "1вия" + , "1-вия" + , "1вият" + , "1-вият" + , "1во" + , "1-во" + , "1вото" + , "1-вото" + , "1ва" + , "1-ва" + , "1вата" + , "1-вата" + ] + , examples (OrdinalData 3) + [ "трети" + , "третите" + , "третия" + , "третият" + , "трето" + , "третото" + , "трета" + , "третата" + , "3ти" + , "3-ти" + , "3тите" + , "3-тите" + , "3тия" + , "3-тия" + , "3тият" + , "3-тият" + , "3то" + , "3-то" + , "3тото" + , "3-тото" + , "3та" + , "3-та" + , "3тата" + , "3-тата" + ] + , examples (OrdinalData 8) + [ "осми" + , "осмите" + , "осмия" + , "осмият" + , "осмо" + , "осмото" + , "осма" + , "осмата" + , "8ми" + , "8-ми" + , "8мите" + , "8-мите" + , "8мия" + , "8-мия" + , "8мият" + , "8-мият" + , "8мо" + , "8-мо" + , "8мото" + , "8-мото" + , "8ма" + , "8-ма" + , "8мата" + , "8-мата" + ] + , examples (OrdinalData 15) + [ "петнадесети" + , "петнадесетите" + , "петнадесетия" + , "петнадесетият" + , "петнадесето" + , "петнадесетото" + , "петнадесета" + , "петнадесетата" + , "15ти" + , "15-ти" + , "15тите" + , "15-тите" + , "15тия" + , "15-тия" + , "15тият" + , "15-тият" + , "15то" + , "15-то" + , "15тото" + , "15-тото" + , "15та" + , "15-та" + , "15тата" + , "15-тата" + ] + , examples (OrdinalData 21) + [ "двадесет и първи" + , "двадесет и първите" + , "двадесет и първия" + , "двадесет и първият" + , "двадесет и първо" + , "двадесет и първото" + , "двадесет и първа" + , "двадесет и първата" + , "21ви" + , "21-ви" + , "21вите" + , "21-вите" + , "21вия" + , "21-вия" + , "21вият" + , "21-вият" + , "21во" + , "21-во" + , "21вото" + , "21-вото" + , "21ва" + , "21-ва" + , "21вата" + , "21-вата" + ] + , examples (OrdinalData 23) + [ "двадесет и трети" + , "двадесет и третите" + , "двадесет и третия" + , "двадесет и третият" + , "двадесет и трето" + , "двадесет и третото" + , "двадесет и трета" + , "двадесет и третата" + , "23ти" + , "23-ти" + , "23тите" + , "23-тите" + , "23тия" + , "23-тия" + , "23тият" + , "23-тият" + , "23то" + , "23-то" + , "23тото" + , "23-тото" + , "23та" + , "23-та" + , "23тата" + , "23-тата" + ] + , examples (OrdinalData 31) + [ "тридесет и първи" + , "тридесет и първите" + , "тридесет и първия" + , "тридесет и първият" + , "тридесет и първо" + , "тридесет и първото" + , "тридесет и първа" + , "тридесет и първата" + , "31ви" + , "31-ви" + , "31вите" + , "31-вите" + , "31вия" + , "31-вия" + , "31вият" + , "31-вият" + , "31во" + , "31-во" + , "31вото" + , "31-вото" + , "31ва" + , "31-ва" + , "31вата" + , "31-вата" + ] + , examples (OrdinalData 48) + [ "четирдесет и осми" + , "четирдесет и осмите" + , "четирдесет и осмия" + , "четирдесет и осмият" + , "четирдесет и осмо" + , "четирдесет и осмото" + , "четирдесет и осма" + , "четирдесет и осмата" + , "48ми" + , "48-ми" + , "48мите" + , "48-мите" + , "48мия" + , "48-мия" + , "48мият" + , "48-мият" + , "48мо" + , "48-мо" + , "48мото" + , "48-мото" + , "48ма" + , "48-ма" + , "48мата" + , "48-мата" + ] + , examples (OrdinalData 99) + [ "деветдесет и девети" + , "деветдесет и деветите" + , "деветдесет и деветия" + , "деветдесет и деветият" + , "деветдесет и девето" + , "деветдесет и деветото" + , "деветдесет и девета" + , "деветдесет и деветата" + , "99ти" + , "99-ти" + , "99тите" + , "99-тите" + , "99тия" + , "99-тия" + , "99тият" + , "99-тият" + , "99то" + , "99-то" + , "99тото" + , "99-тото" + , "99та" + , "99-та" + , "99тата" + , "99-тата" + ] + ] diff --git a/Duckling/Ordinal/BG/Rules.hs b/Duckling/Ordinal/BG/Rules.hs new file mode 100644 --- /dev/null +++ b/Duckling/Ordinal/BG/Rules.hs @@ -0,0 +1,110 @@ +-- Copyright (c) 2016-present, Facebook, Inc. +-- All rights reserved. +-- +-- This source code is licensed under the BSD-style license found in the +-- LICENSE file in the root directory of this source tree. An additional grant +-- of patent rights can be found in the PATENTS file in the same directory. + + +{-# LANGUAGE GADTs #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE NoRebindableSyntax #-} + +module Duckling.Ordinal.BG.Rules + ( rules + ) where + +import Data.HashMap.Strict (HashMap) +import Data.Text (Text) +import Prelude +import qualified Data.HashMap.Strict as HashMap +import qualified Data.Text as Text + +import Duckling.Dimensions.Types +import Duckling.Numeral.Helpers (parseInt) +import Duckling.Ordinal.Helpers +import Duckling.Regex.Types +import Duckling.Types + +ordinalsMap :: HashMap Text Int +ordinalsMap = HashMap.fromList + [ ( "първ" , 1 ) + , ( "втор" , 2 ) + , ( "трет" , 3 ) + , ( "четвърт" , 4 ) + , ( "пет" , 5 ) + , ( "шест" , 6 ) + , ( "седм" , 7 ) + , ( "осм" , 8 ) + , ( "девет" , 9 ) + , ( "десет" , 10 ) + , ( "единадесет" , 11 ) + , ( "дванадесет" , 12 ) + , ( "тринадесет" , 13 ) + , ( "четиринадесет", 14 ) + , ( "петнадесет" , 15 ) + , ( "шестнадесет" , 16 ) + , ( "седемнадесет" , 17 ) + , ( "осемнадесет" , 18 ) + , ( "деветнадесет" , 19 ) + , ( "двадесет" , 20 ) + ] + +ruleOrdinalsFirstth :: Rule +ruleOrdinalsFirstth = Rule + { name = "ordinals (first..19th)" + , pattern = + [ regex "(първ|втор|трет|четвърт|пет|шест|седм|осм|девет|десет|единадесет|дванадесет|тринадесет|четиринадесет|петнадесет|шестнадесет|седемнадесет|осемнадесет|деветнадесет|двадесет)(и(я(т)?|те)?|а(та)?|о(то)?)" + ] + , prod = \tokens -> case tokens of + (Token RegexMatch (GroupMatch (match:_)):_) -> + ordinal <$> HashMap.lookup (Text.toLower match) ordinalsMap + _ -> Nothing + } + +dozensMap :: HashMap Text Int +dozensMap = HashMap.fromList + [ ( "двадесет" , 20 ) + , ( "тридесет" , 30 ) + , ( "четирдесет", 40 ) + , ( "петдесет" , 50 ) + , ( "шестдесет" , 60 ) + , ( "седемдесет", 70 ) + , ( "осемдесет" , 80 ) + , ( "деветдесет", 90 ) + ] + +ruleOrdinal :: Rule +ruleOrdinal = Rule + { name = "ordinal 21..99" + , pattern = + [ regex "(двадесет|тридесет|четирдесет|петдесет|шестдесет|седемдесет|осемдесет|деветдесет)" + , regex "и (първ|втор|трет|четвърт|пет|шест|седм|осм|девет)(и(ят?|те)?|а(та)?|о(то)?)" + ] + , prod = \tokens -> case tokens of + (Token RegexMatch (GroupMatch (m1:_)): + Token RegexMatch (GroupMatch (m2:_)): + _) -> do + dozen <- HashMap.lookup (Text.toLower m1) dozensMap + unit <- HashMap.lookup (Text.toLower m2) ordinalsMap + Just . ordinal $ dozen + unit + _ -> Nothing + } + +ruleOrdinalDigits :: Rule +ruleOrdinalDigits = Rule + { name = "ordinal (digits)" + , pattern = + [ regex "0*(\\d+)-?((в|р|м|т)(и(я(т)?|те)?|а(та)?|о(то)?))" + ] + , prod = \tokens -> case tokens of + (Token RegexMatch (GroupMatch (match:_)):_) -> ordinal <$> parseInt match + _ -> Nothing + } + +rules :: [Rule] +rules = + [ ruleOrdinal + , ruleOrdinalDigits + , ruleOrdinalsFirstth + ] diff --git a/Duckling/Ordinal/DA/Corpus.hs b/Duckling/Ordinal/DA/Corpus.hs --- a/Duckling/Ordinal/DA/Corpus.hs +++ b/Duckling/Ordinal/DA/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale DA Nothing}, allExamples) +corpus = (testContext {locale = makeLocale DA Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = diff --git a/Duckling/Ordinal/DE/Corpus.hs b/Duckling/Ordinal/DE/Corpus.hs --- a/Duckling/Ordinal/DE/Corpus.hs +++ b/Duckling/Ordinal/DE/Corpus.hs @@ -22,10 +22,10 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale DE Nothing}, allExamples) +corpus = (testContext {locale = makeLocale DE Nothing}, testOptions, allExamples) negativeCorpus :: NegativeCorpus -negativeCorpus = (testContext {locale = makeLocale DE Nothing}, examples) +negativeCorpus = (testContext {locale = makeLocale DE Nothing}, testOptions, examples) where examples = [ "1.1" diff --git a/Duckling/Ordinal/EL/Corpus.hs b/Duckling/Ordinal/EL/Corpus.hs --- a/Duckling/Ordinal/EL/Corpus.hs +++ b/Duckling/Ordinal/EL/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale EL Nothing}, allExamples) +corpus = (testContext {locale = makeLocale EL Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Ordinal/EN/Corpus.hs b/Duckling/Ordinal/EN/Corpus.hs --- a/Duckling/Ordinal/EN/Corpus.hs +++ b/Duckling/Ordinal/EN/Corpus.hs @@ -9,16 +9,17 @@ {-# LANGUAGE OverloadedStrings #-} module Duckling.Ordinal.EN.Corpus - ( corpus ) where + ( corpus + ) where -import Prelude import Data.String +import Prelude import Duckling.Ordinal.Types import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext, allExamples) +corpus = (testContext, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Ordinal/EN/Rules.hs b/Duckling/Ordinal/EN/Rules.hs --- a/Duckling/Ordinal/EN/Rules.hs +++ b/Duckling/Ordinal/EN/Rules.hs @@ -70,7 +70,6 @@ , ( "ninety", 90 ) ] - ruleOrdinals :: Rule ruleOrdinals = Rule { name = "ordinals (first..twentieth,thirtieth,...)" diff --git a/Duckling/Ordinal/ES/Corpus.hs b/Duckling/Ordinal/ES/Corpus.hs --- a/Duckling/Ordinal/ES/Corpus.hs +++ b/Duckling/Ordinal/ES/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale ES Nothing}, allExamples) +corpus = (testContext {locale = makeLocale ES Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Ordinal/ET/Corpus.hs b/Duckling/Ordinal/ET/Corpus.hs --- a/Duckling/Ordinal/ET/Corpus.hs +++ b/Duckling/Ordinal/ET/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale ET Nothing}, allExamples) +corpus = (testContext {locale = makeLocale ET Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = diff --git a/Duckling/Ordinal/FR/Corpus.hs b/Duckling/Ordinal/FR/Corpus.hs --- a/Duckling/Ordinal/FR/Corpus.hs +++ b/Duckling/Ordinal/FR/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale FR Nothing}, allExamples) +corpus = (testContext {locale = makeLocale FR Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Ordinal/GA/Corpus.hs b/Duckling/Ordinal/GA/Corpus.hs --- a/Duckling/Ordinal/GA/Corpus.hs +++ b/Duckling/Ordinal/GA/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale GA Nothing}, allExamples) +corpus = (testContext {locale = makeLocale GA Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Ordinal/HE/Corpus.hs b/Duckling/Ordinal/HE/Corpus.hs --- a/Duckling/Ordinal/HE/Corpus.hs +++ b/Duckling/Ordinal/HE/Corpus.hs @@ -19,7 +19,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale HE Nothing}, allExamples) +corpus = (testContext {locale = makeLocale HE Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Ordinal/HI/Corpus.hs b/Duckling/Ordinal/HI/Corpus.hs --- a/Duckling/Ordinal/HI/Corpus.hs +++ b/Duckling/Ordinal/HI/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale HI Nothing}, allExamples) +corpus = (testContext {locale = makeLocale HI Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Ordinal/HR/Corpus.hs b/Duckling/Ordinal/HR/Corpus.hs --- a/Duckling/Ordinal/HR/Corpus.hs +++ b/Duckling/Ordinal/HR/Corpus.hs @@ -19,7 +19,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale HR Nothing}, allExamples) +corpus = (testContext {locale = makeLocale HR Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Ordinal/HU/Corpus.hs b/Duckling/Ordinal/HU/Corpus.hs --- a/Duckling/Ordinal/HU/Corpus.hs +++ b/Duckling/Ordinal/HU/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale HU Nothing}, allExamples) +corpus = (testContext {locale = makeLocale HU Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Ordinal/ID/Corpus.hs b/Duckling/Ordinal/ID/Corpus.hs --- a/Duckling/Ordinal/ID/Corpus.hs +++ b/Duckling/Ordinal/ID/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale ID Nothing}, allExamples) +corpus = (testContext {locale = makeLocale ID Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Ordinal/IT/Corpus.hs b/Duckling/Ordinal/IT/Corpus.hs --- a/Duckling/Ordinal/IT/Corpus.hs +++ b/Duckling/Ordinal/IT/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale IT Nothing}, allExamples) +corpus = (testContext {locale = makeLocale IT Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Ordinal/JA/Corpus.hs b/Duckling/Ordinal/JA/Corpus.hs --- a/Duckling/Ordinal/JA/Corpus.hs +++ b/Duckling/Ordinal/JA/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale JA Nothing}, allExamples) +corpus = (testContext {locale = makeLocale JA Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = diff --git a/Duckling/Ordinal/KO/Corpus.hs b/Duckling/Ordinal/KO/Corpus.hs --- a/Duckling/Ordinal/KO/Corpus.hs +++ b/Duckling/Ordinal/KO/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale KO Nothing}, allExamples) +corpus = (testContext {locale = makeLocale KO Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Ordinal/NB/Corpus.hs b/Duckling/Ordinal/NB/Corpus.hs --- a/Duckling/Ordinal/NB/Corpus.hs +++ b/Duckling/Ordinal/NB/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale NB Nothing}, allExamples) +corpus = (testContext {locale = makeLocale NB Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Ordinal/NL/Corpus.hs b/Duckling/Ordinal/NL/Corpus.hs --- a/Duckling/Ordinal/NL/Corpus.hs +++ b/Duckling/Ordinal/NL/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale NL Nothing}, allExamples) +corpus = (testContext {locale = makeLocale NL Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Ordinal/PL/Corpus.hs b/Duckling/Ordinal/PL/Corpus.hs --- a/Duckling/Ordinal/PL/Corpus.hs +++ b/Duckling/Ordinal/PL/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale PL Nothing}, allExamples) +corpus = (testContext {locale = makeLocale PL Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = diff --git a/Duckling/Ordinal/PT/Corpus.hs b/Duckling/Ordinal/PT/Corpus.hs --- a/Duckling/Ordinal/PT/Corpus.hs +++ b/Duckling/Ordinal/PT/Corpus.hs @@ -21,7 +21,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale PT Nothing}, allExamples) +corpus = (testContext {locale = makeLocale PT Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Ordinal/RO/Corpus.hs b/Duckling/Ordinal/RO/Corpus.hs --- a/Duckling/Ordinal/RO/Corpus.hs +++ b/Duckling/Ordinal/RO/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale RO Nothing}, allExamples) +corpus = (testContext {locale = makeLocale RO Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Ordinal/RU/Corpus.hs b/Duckling/Ordinal/RU/Corpus.hs --- a/Duckling/Ordinal/RU/Corpus.hs +++ b/Duckling/Ordinal/RU/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale RU Nothing}, allExamples) +corpus = (testContext {locale = makeLocale RU Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Ordinal/RU/Rules.hs b/Duckling/Ordinal/RU/Rules.hs --- a/Duckling/Ordinal/RU/Rules.hs +++ b/Duckling/Ordinal/RU/Rules.hs @@ -8,14 +8,17 @@ {-# LANGUAGE GADTs #-} {-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE NoRebindableSyntax #-} module Duckling.Ordinal.RU.Rules - ( rules ) where + ( rules + ) where -import Control.Monad (join) -import qualified Data.Text as Text -import Prelude +import Data.HashMap.Strict (HashMap) import Data.String +import Prelude +import qualified Data.HashMap.Strict as HashMap +import qualified Data.Text as Text import Duckling.Dimensions.Types import Duckling.Numeral.Helpers (parseInt) @@ -23,6 +26,42 @@ import Duckling.Regex.Types import Duckling.Types +ordinalsFirstthMap :: HashMap Text.Text Int +ordinalsFirstthMap = HashMap.fromList + [ ( "перв", 1 ) + , ( "втор", 2 ) + , ( "трет", 3 ) + , ( "четверт", 4 ) + , ( "пят", 5 ) + , ( "шест", 6 ) + , ( "седьм", 7 ) + , ( "восьм", 8 ) + , ( "девят", 9 ) + , ( "десят", 10 ) + , ( "одинадцат", 11 ) + , ( "двенадцат", 12 ) + , ( "тринадцат", 13 ) + , ( "четырнадцат", 14 ) + , ( "пятнадцат", 15 ) + , ( "шестнадцат", 16 ) + , ( "семнадцат", 17 ) + , ( "восемнадцат", 18 ) + , ( "девятнадцат", 19 ) + , ( "двадцат", 20 ) + ] + +cardinalsMap :: HashMap Text.Text Int +cardinalsMap = HashMap.fromList + [ ( "двадцать", 20 ) + , ( "тридцать", 30 ) + , ( "сорок", 40 ) + , ( "пятьдесят", 50 ) + , ( "шестьдесят", 60 ) + , ( "семьдесят", 70 ) + , ( "восемьдесят", 80 ) + , ( "девяносто", 90 ) + ] + ruleOrdinalsFirstth :: Rule ruleOrdinalsFirstth = Rule { name = "ordinals (first..19th)" @@ -30,28 +69,8 @@ [ regex "(перв|втор|трет|четверт|пят|шест|седьм|восьм|девят|десят|одинадцат|двенадцат|тринадцат|четырнадцат|пятнадцат|шестнадцат|семнадцат|восемнадцат|девятнадцат|двадцат)(ье(го|й)?|ого|ый|ой|ий|ая|ое|ья)" ] , prod = \tokens -> case tokens of - (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of - "перв" -> Just $ ordinal 1 - "втор" -> Just $ ordinal 2 - "трет" -> Just $ ordinal 3 - "четверт" -> Just $ ordinal 4 - "пят" -> Just $ ordinal 5 - "шест" -> Just $ ordinal 6 - "седьм" -> Just $ ordinal 7 - "восьм" -> Just $ ordinal 8 - "девят" -> Just $ ordinal 9 - "десят" -> Just $ ordinal 10 - "одинадцат" -> Just $ ordinal 11 - "двенадцат" -> Just $ ordinal 12 - "тринадцат" -> Just $ ordinal 13 - "четырнадцат" -> Just $ ordinal 14 - "пятнадцат" -> Just $ ordinal 15 - "шестнадцат" -> Just $ ordinal 16 - "семнадцат" -> Just $ ordinal 17 - "восемнадцат" -> Just $ ordinal 18 - "девятнадцат" -> Just $ ordinal 19 - "двадцат" -> Just $ ordinal 20 - _ -> Nothing + (Token RegexMatch (GroupMatch (match:_)):_) -> + ordinal <$> HashMap.lookup (Text.toLower match) ordinalsFirstthMap _ -> Nothing } @@ -66,27 +85,8 @@ (Token RegexMatch (GroupMatch (m1:_)): Token RegexMatch (GroupMatch (m2:_)): _) -> do - dozen <- case Text.toLower m1 of - "двадцать" -> Just 20 - "тридцать" -> Just 30 - "сорок" -> Just 40 - "пятьдесят" -> Just 50 - "шестьдесят" -> Just 60 - "семьдесят" -> Just 70 - "восемьдесят" -> Just 80 - "девяносто" -> Just 90 - _ -> Nothing - unit <- case Text.toLower m2 of - "перв" -> Just 1 - "втор" -> Just 2 - "трет" -> Just 3 - "четверт" -> Just 4 - "пят" -> Just 5 - "шест" -> Just 6 - "седьм" -> Just 7 - "восьм" -> Just 8 - "девят" -> Just 9 - _ -> Nothing + dozen <- HashMap.lookup (Text.toLower m1) cardinalsMap + unit <- HashMap.lookup (Text.toLower m2) ordinalsFirstthMap Just . ordinal $ dozen + unit _ -> Nothing } diff --git a/Duckling/Ordinal/SV/Corpus.hs b/Duckling/Ordinal/SV/Corpus.hs --- a/Duckling/Ordinal/SV/Corpus.hs +++ b/Duckling/Ordinal/SV/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale SV Nothing}, allExamples) +corpus = (testContext {locale = makeLocale SV Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Ordinal/TR/Corpus.hs b/Duckling/Ordinal/TR/Corpus.hs --- a/Duckling/Ordinal/TR/Corpus.hs +++ b/Duckling/Ordinal/TR/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale TR Nothing}, allExamples) +corpus = (testContext {locale = makeLocale TR Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Ordinal/Types.hs b/Duckling/Ordinal/Types.hs --- a/Duckling/Ordinal/Types.hs +++ b/Duckling/Ordinal/Types.hs @@ -28,7 +28,7 @@ instance Resolve OrdinalData where type ResolvedValue OrdinalData = OrdinalData - resolve _ x = Just x + resolve _ _ x = Just (x, False) instance ToJSON OrdinalData where toJSON (OrdinalData value) = object diff --git a/Duckling/Ordinal/UK/Corpus.hs b/Duckling/Ordinal/UK/Corpus.hs --- a/Duckling/Ordinal/UK/Corpus.hs +++ b/Duckling/Ordinal/UK/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale UK Nothing}, allExamples) +corpus = (testContext {locale = makeLocale UK Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Ordinal/VI/Corpus.hs b/Duckling/Ordinal/VI/Corpus.hs --- a/Duckling/Ordinal/VI/Corpus.hs +++ b/Duckling/Ordinal/VI/Corpus.hs @@ -19,7 +19,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale VI Nothing}, allExamples) +corpus = (testContext {locale = makeLocale VI Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Ordinal/ZH/Corpus.hs b/Duckling/Ordinal/ZH/Corpus.hs --- a/Duckling/Ordinal/ZH/Corpus.hs +++ b/Duckling/Ordinal/ZH/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale ZH Nothing}, allExamples) +corpus = (testContext {locale = makeLocale ZH Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/PhoneNumber/Corpus.hs b/Duckling/PhoneNumber/Corpus.hs --- a/Duckling/PhoneNumber/Corpus.hs +++ b/Duckling/PhoneNumber/Corpus.hs @@ -20,10 +20,10 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext, allExamples) +corpus = (testContext, testOptions, allExamples) negativeCorpus :: NegativeCorpus -negativeCorpus = (testContext, examples) +negativeCorpus = (testContext, testOptions, examples) where examples = [ "12345" diff --git a/Duckling/PhoneNumber/PT/Corpus.hs b/Duckling/PhoneNumber/PT/Corpus.hs --- a/Duckling/PhoneNumber/PT/Corpus.hs +++ b/Duckling/PhoneNumber/PT/Corpus.hs @@ -21,7 +21,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale PT Nothing}, allExamples) +corpus = (testContext {locale = makeLocale PT Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/PhoneNumber/Types.hs b/Duckling/PhoneNumber/Types.hs --- a/Duckling/PhoneNumber/Types.hs +++ b/Duckling/PhoneNumber/Types.hs @@ -37,8 +37,8 @@ instance Resolve PhoneNumberData where type ResolvedValue PhoneNumberData = PhoneNumberValue - resolve _ PhoneNumberData {prefix, number, extension} = Just PhoneNumberValue - {value = Text.concat [p, number, e]} + resolve _ _ PhoneNumberData {prefix, number, extension} = Just + (PhoneNumberValue {value = Text.concat [p, number, e]}, False) where p = case prefix of Just p -> "(+" <> TS.showt p <> ") " diff --git a/Duckling/Quantity/AR/Corpus.hs b/Duckling/Quantity/AR/Corpus.hs --- a/Duckling/Quantity/AR/Corpus.hs +++ b/Duckling/Quantity/AR/Corpus.hs @@ -21,7 +21,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale AR Nothing}, allExamples) +corpus = (testContext {locale = makeLocale AR Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Quantity/EN/Corpus.hs b/Duckling/Quantity/EN/Corpus.hs --- a/Duckling/Quantity/EN/Corpus.hs +++ b/Duckling/Quantity/EN/Corpus.hs @@ -18,7 +18,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext, allExamples) +corpus = (testContext, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Quantity/FR/Corpus.hs b/Duckling/Quantity/FR/Corpus.hs --- a/Duckling/Quantity/FR/Corpus.hs +++ b/Duckling/Quantity/FR/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale FR Nothing}, allExamples) +corpus = (testContext {locale = makeLocale FR Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Quantity/HR/Corpus.hs b/Duckling/Quantity/HR/Corpus.hs --- a/Duckling/Quantity/HR/Corpus.hs +++ b/Duckling/Quantity/HR/Corpus.hs @@ -19,7 +19,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale HR Nothing}, allExamples) +corpus = (testContext {locale = makeLocale HR Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Quantity/KO/Corpus.hs b/Duckling/Quantity/KO/Corpus.hs --- a/Duckling/Quantity/KO/Corpus.hs +++ b/Duckling/Quantity/KO/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale KO Nothing}, allExamples) +corpus = (testContext {locale = makeLocale KO Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Quantity/PT/Corpus.hs b/Duckling/Quantity/PT/Corpus.hs --- a/Duckling/Quantity/PT/Corpus.hs +++ b/Duckling/Quantity/PT/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale PT Nothing}, allExamples) +corpus = (testContext {locale = makeLocale PT Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Quantity/RO/Corpus.hs b/Duckling/Quantity/RO/Corpus.hs --- a/Duckling/Quantity/RO/Corpus.hs +++ b/Duckling/Quantity/RO/Corpus.hs @@ -20,7 +20,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale RO Nothing}, allExamples) +corpus = (testContext {locale = makeLocale RO Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Quantity/RU/Corpus.hs b/Duckling/Quantity/RU/Corpus.hs --- a/Duckling/Quantity/RU/Corpus.hs +++ b/Duckling/Quantity/RU/Corpus.hs @@ -21,7 +21,7 @@ import Duckling.Testing.Types corpus :: Corpus -corpus = (testContext {locale = makeLocale RU Nothing}, allExamples) +corpus = (testContext {locale = makeLocale RU Nothing}, testOptions, allExamples) allExamples :: [Example] allExamples = concat diff --git a/Duckling/Quantity/Types.hs b/Duckling/Quantity/Types.hs --- a/Duckling/Quantity/Types.hs +++ b/Duckling/Quantity/Types.hs @@ -55,33 +55,33 @@ instance Resolve QuantityData where type ResolvedValue QuantityData = QuantityValue - resolve _ QuantityData {value = Just value + resolve _ _ QuantityData {value = Just value , unit = Just unit , aproduct = aproduct} - = Just $ simple unit value aproduct + = Just (simple unit value aproduct, False) - resolve _ QuantityData {value = Nothing + resolve _ _ QuantityData {value = Nothing , unit = Just unit , aproduct = aproduct , minValue = Just from , maxValue = Just to} - = Just $ between unit (from, to) aproduct + = Just (between unit (from, to) aproduct, False) - resolve _ QuantityData {value = Nothing + resolve _ _ QuantityData {value = Nothing , unit = Just unit , aproduct = aproduct , minValue = Just from , maxValue = Nothing} - = Just $ above unit from aproduct + = Just (above unit from aproduct, False) - resolve _ QuantityData {value = Nothing + resolve _ _ QuantityData {value = Nothing , unit = Just unit , aproduct = aproduct , minValue = Nothing , maxValue = Just to} - = Just $ under unit to aproduct + = Just (under unit to aproduct, False) - resolve _ _ = Nothing + resolve _ _ _ = Nothing data IntervalDirection = Above | Under deriving (Eq, Generic, Hashable, Ord, Show, NFData) diff --git a/Duckling/Ranking/Classifiers.hs b/Duckling/Ranking/Classifiers.hs --- a/Duckling/Ranking/Classifiers.hs +++ b/Duckling/Ranking/Classifiers.hs @@ -45,6 +45,7 @@ import qualified Duckling.Ranking.Classifiers.RO_XX as RO_XXClassifiers import qualified Duckling.Ranking.Classifiers.RU_XX as RU_XXClassifiers import qualified Duckling.Ranking.Classifiers.SV_XX as SV_XXClassifiers +import qualified Duckling.Ranking.Classifiers.TA_XX as TA_XXClassifiers import qualified Duckling.Ranking.Classifiers.TR_XX as TR_XXClassifiers import qualified Duckling.Ranking.Classifiers.UK_XX as UK_XXClassifiers import qualified Duckling.Ranking.Classifiers.VI_XX as VI_XXClassifiers @@ -82,6 +83,7 @@ classifiers (Locale RO _) = RO_XXClassifiers.classifiers classifiers (Locale RU _) = RU_XXClassifiers.classifiers classifiers (Locale SV _) = SV_XXClassifiers.classifiers +classifiers (Locale TA _) = TA_XXClassifiers.classifiers classifiers (Locale TR _) = TR_XXClassifiers.classifiers classifiers (Locale UK _) = UK_XXClassifiers.classifiers classifiers (Locale VI _) = VI_XXClassifiers.classifiers diff --git a/Duckling/Ranking/Classifiers/DE_XX.hs b/Duckling/Ranking/Classifiers/DE_XX.hs --- a/Duckling/Ranking/Classifiers/DE_XX.hs +++ b/Duckling/Ranking/Classifiers/DE_XX.hs @@ -35,11 +35,11 @@ likelihoods = HashMap.fromList [], n = 0}}), ("integer (numeric)", Classifier{okData = - ClassData{prior = -0.9246589815446716, unseen = -4.795790545596741, + ClassData{prior = -0.921320080279157, unseen = -4.795790545596741, likelihoods = HashMap.fromList [("", 0.0)], n = 119}, koData = - ClassData{prior = -0.5052854433903752, unseen = -5.209486152841421, - likelihoods = HashMap.fromList [("", 0.0)], n = 181}}), + ClassData{prior = -0.507486722500476, unseen = -5.204006687076795, + likelihoods = HashMap.fromList [("", 0.0)], n = 180}}), ("exactly ", Classifier{okData = ClassData{prior = 0.0, unseen = -2.3025850929940455, @@ -52,13 +52,6 @@ koData = ClassData{prior = -infinity, unseen = -1.3862943611198906, likelihoods = HashMap.fromList [], n = 0}}), - ("Father's Day", - Classifier{okData = - ClassData{prior = 0.0, unseen = -1.0986122886681098, - likelihoods = HashMap.fromList [("", 0.0)], n = 1}, - koData = - ClassData{prior = -infinity, unseen = -0.6931471805599453, - likelihoods = HashMap.fromList [], n = 0}}), (" (as relative minutes)", Classifier{okData = ClassData{prior = -infinity, unseen = -1.0986122886681098, @@ -216,6 +209,13 @@ (" am|pm", -1.9095425048844386), ("hour", -1.349926716949016), ("minute", -2.1972245773362196)], n = 8}}), + ("Neujahr", + Classifier{okData = + ClassData{prior = 0.0, unseen = -1.3862943611198906, + likelihoods = HashMap.fromList [("", 0.0)], n = 2}, + koData = + ClassData{prior = -infinity, unseen = -0.6931471805599453, + likelihoods = HashMap.fromList [], n = 0}}), ("absorption of , after named day", Classifier{okData = ClassData{prior = -7.410797215372185e-2, @@ -301,6 +301,13 @@ [("hh:mmtime-of-day (latent)", -1.0986122886681098), ("minutehour", -1.0986122886681098)], n = 1}}), + ("Halloween", + Classifier{okData = + ClassData{prior = 0.0, unseen = -1.0986122886681098, + likelihoods = HashMap.fromList [("", 0.0)], n = 1}, + koData = + ClassData{prior = -infinity, unseen = -0.6931471805599453, + likelihoods = HashMap.fromList [], n = 0}}), ("between and (interval)", Classifier{okData = ClassData{prior = -0.6931471805599453, @@ -365,6 +372,13 @@ koData = ClassData{prior = -infinity, unseen = -0.6931471805599453, likelihoods = HashMap.fromList [], n = 0}}), + ("Valentinstag", + Classifier{okData = + ClassData{prior = 0.0, unseen = -1.0986122886681098, + likelihoods = HashMap.fromList [("", 0.0)], n = 1}, + koData = + ClassData{prior = -infinity, unseen = -0.6931471805599453, + likelihoods = HashMap.fromList [], n = 0}}), ("hour (grain)", Classifier{okData = ClassData{prior = -0.15415067982725836, @@ -391,285 +405,286 @@ n = 1}}), ("intersect", Classifier{okData = - ClassData{prior = -0.2639842810219578, unseen = -6.92951677076365, + ClassData{prior = -0.26452876747706405, + unseen = -6.926577033222725, likelihoods = HashMap.fromList - [("Samstag o'clock", -6.23539063760472), - ("hourday", -4.982627669109352), - (" - (interval)year", -4.982627669109352), - ("dayhour", -2.571828991475074), - ("daymonth", -3.167337702471103), + [("Samstag o'clock", -6.2324480165505225), + ("hourday", -4.979685048055154), + (" - (interval)year", -4.979685048055154), + ("dayhour", -2.568886370420876), + ("daymonth", -3.1879255788270995), ("(ordinal) year o'clock", - -6.23539063760472), - ("monthyear", -4.5306425453662955), - ("yearhour", -6.23539063760472), - ("Juliintersect", -6.23539063760472), - ("intersect o'clock", -4.095324474108449), - ("christmasyear", -6.23539063760472), - ("after lunchat ", -6.23539063760472), + -6.2324480165505225), + ("monthyear", -4.527699924312097), + ("yearhour", -6.2324480165505225), + ("Juliintersect", -6.2324480165505225), + ("intersect o'clock", -4.092381853054252), + ("after lunchat ", -6.2324480165505225), ("absorption of , after named daymm/dd/yyyy", - -6.23539063760472), - ("intersectJuli", -5.5422434570447745), - (" (ordinal)Dienstag", -6.23539063760472), - ("intersect by 'of', 'from', 'syear", -5.829925529496556), - (" am|pmintersect", -5.136778348936611), - (" (ordinal)September", -5.829925529496556), - ("intersect