{"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE NoRebindableSyntax #-}\n{-# LANGUAGE RecordWildCards #-}\n\nmodule Duckling.Api\n ( analyze\n , formatToken\n , parse\n , supportedDimensions\n ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport Data.HashSet (HashSet)\nimport Data.Text (Text)\nimport Prelude\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.HashSet as HashSet\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Dimensions\nimport Duckling.Engine\nimport Duckling.Locale\nimport Duckling.Ranking.Classifiers\nimport Duckling.Ranking.Rank\nimport Duckling.Resolve\nimport Duckling.Rules\nimport Duckling.Types\n\n-- | Parses `input` and returns a curated list of entities found.\nparse\n :: Text\n -> Context\n -> Options\n -> [Seal Dimension]\n -> [Entity]\nparse input ctx options =\n map (formatToken input)\n . analyze input ctx options\n . HashSet.fromList\n\nsupportedDimensions :: HashMap Lang [Seal Dimension]\nsupportedDimensions =\n HashMap.fromList [ (l, allDimensions l) | l <- [minBound..maxBound] ]\n\n-- | Returns a curated list of resolved tokens found\n-- When `targets` is non-empty, returns only tokens of such dimensions.\nanalyze\n :: Text\n -> Context\n -> Options\n -> HashSet (Seal Dimension)\n -> [ResolvedToken]\nanalyze input context@Context{..} options targets =\n rank (classifiers locale) targets\n $ filter isRelevantDimension\n $ parseAndResolve (rulesFor locale targets) input context options\n where\n isRelevantDimension Resolved{node = Node{token = (Token d _)}} =\n HashSet.null targets || HashSet.member (Seal d) targets\n\n-- | Converts the resolved token to the API format\nformatToken :: Text -> ResolvedToken -> Entity\nformatToken sentence\n (Resolved (Range start end) node@Node{token = Token dim _} value latent)\n = Entity (toName dim) body value start end latent node\n where\n body = Text.drop start $ Text.take end sentence\n", "num_lines": 75} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE NoRebindableSyntax #-}\n\n-- | Everything needed to run Duckling.\n\nmodule Duckling.Core\n ( Context(..)\n , Dimension(..)\n , Entity(..)\n , Lang(..)\n , Locale\n , Node(..)\n , Options(..)\n , Range(..)\n , Region(..)\n , ResolvedVal(..)\n , Seal(..)\n , withSeal\n , fromName\n , makeLocale\n , toJText\n , toName\n\n -- Duckling API\n , parse\n , supportedDimensions\n , allLocales\n\n -- Reference time builders\n , currentReftime\n , fromZonedTime\n , makeReftime\n ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport Data.Text (Text)\nimport Data.Time\nimport Data.Time.LocalTime.TimeZone.Series\nimport Prelude\nimport qualified Data.HashMap.Strict as HashMap\n\nimport Duckling.Api\nimport Duckling.Dimensions.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Types\n\n-- | Builds a `DucklingTime` for timezone `tz` at `utcTime`.\n-- If no `series` found for `tz`, uses UTC.\nmakeReftime :: HashMap Text TimeZoneSeries -> Text -> UTCTime -> DucklingTime\nmakeReftime series tz utcTime = DucklingTime $ ZoneSeriesTime ducklingTime tzs\n where\n tzs = HashMap.lookupDefault (TimeZoneSeries utc []) tz series\n ducklingTime = toUTC $ utcToLocalTime' tzs utcTime\n\n-- | Builds a `DucklingTime` for timezone `tz` at current time.\n-- If no `series` found for `tz`, uses UTC.\ncurrentReftime :: HashMap Text TimeZoneSeries -> Text -> IO DucklingTime\ncurrentReftime series tz = makeReftime series tz <$> getCurrentTime\n\n-- | Builds a `DucklingTime` from a `ZonedTime`.\nfromZonedTime :: ZonedTime -> DucklingTime\nfromZonedTime (ZonedTime localTime timeZone) = DucklingTime $\n ZoneSeriesTime (toUTC localTime) (TimeZoneSeries timeZone [])\n", "num_lines": 71} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE NamedFieldPuns #-}\n{-# LANGUAGE NoRebindableSyntax #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Debug\n ( allParses\n , debug\n , debugCustom\n , fullParses\n , ptree\n ) where\n\nimport Data.Maybe\nimport Data.Text (Text)\nimport Prelude\nimport qualified Data.HashSet as HashSet\nimport qualified Data.Text as Text\nimport qualified Data.Text.IO as Text\n\nimport Duckling.Api\nimport Duckling.Dimensions.Types\nimport Duckling.Engine\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Rules\nimport Duckling.Testing.Types\nimport Duckling.Types\n\n-- -----------------------------------------------------------------\n-- API\n\ndebug :: Locale -> Text -> [Seal Dimension] -> IO [Entity]\ndebug locale = debugCustom testContext {locale = locale} testOptions\n\nallParses :: Locale -> Text -> [Seal Dimension] -> IO [Entity]\nallParses l input targets = debugTokens input $ parses l input targets\n\nfullParses :: Locale -> Text -> [Seal Dimension] -> IO [Entity]\nfullParses l input targets =\n debugTokens\n input\n $ filter\n (\\Resolved{range = Range start end} -> start == 0 && end == n)\n $ parses l input targets\n where\n n = Text.length input\n\ndebugCustom :: Context -> Options -> Text -> [Seal Dimension] -> IO [Entity]\ndebugCustom context options input targets =\n debugTokens\n input\n $ analyze input context options $ HashSet.fromList targets\n\nptree :: Text -> Entity -> IO ()\nptree input Entity {enode} = pnode input 0 enode\n\n-- -----------------------------------------------------------------\n-- Internals\n\nparses :: Locale -> Text -> [Seal Dimension] -> [ResolvedToken]\nparses l input targets =\n filter isRelevantDimension tokens\n where\n tokens = parseAndResolve rules input testContext {locale = l} testOptions\n rules = rulesFor l $ HashSet.fromList targets\n isRelevantDimension Resolved{node = Node{token = (Token d _)}} =\n case targets of\n [] -> True\n _ -> elem (Seal d) targets\n\ndebugTokens :: Text -> [ResolvedToken] -> IO [Entity]\ndebugTokens input tokens = do\n mapM_ (ptree input) entities\n return entities\n where entities = map (formatToken input) tokens\n\npnode :: Text -> Int -> Node -> IO ()\npnode input depth Node {children, rule, nodeRange = Range start end} = do\n Text.putStrLn out\n mapM_ (pnode input (depth + 1)) children\n where\n out = Text.concat [ Text.replicate depth \"-- \", name, \" (\", body, \")\" ]\n name = fromMaybe \"regex\" rule\n body = Text.drop start $ Text.take end input\n", "num_lines": 92} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE NoRebindableSyntax #-}\n\nmodule Duckling.Dimensions\n ( allDimensions\n , explicitDimensions\n ) where\n\nimport Data.HashSet (HashSet)\nimport Prelude\nimport qualified Data.HashSet as HashSet\n\nimport Duckling.Dimensions.Types\nimport Duckling.Locale\nimport Duckling.Types\nimport qualified Duckling.Dimensions.Common as CommonDimensions\nimport qualified Duckling.Dimensions.AF as AFDimensions\nimport qualified Duckling.Dimensions.AR as ARDimensions\nimport qualified Duckling.Dimensions.BG as BGDimensions\nimport qualified Duckling.Dimensions.BN as BNDimensions\nimport qualified Duckling.Dimensions.CA as CADimensions\nimport qualified Duckling.Dimensions.CS as CSDimensions\nimport qualified Duckling.Dimensions.DA as DADimensions\nimport qualified Duckling.Dimensions.DE as DEDimensions\nimport qualified Duckling.Dimensions.EL as ELDimensions\nimport qualified Duckling.Dimensions.EN as ENDimensions\nimport qualified Duckling.Dimensions.ES as ESDimensions\nimport qualified Duckling.Dimensions.ET as ETDimensions\nimport qualified Duckling.Dimensions.FA as FADimensions\nimport qualified Duckling.Dimensions.FI as FIDimensions\nimport qualified Duckling.Dimensions.FR as FRDimensions\nimport qualified Duckling.Dimensions.GA as GADimensions\nimport qualified Duckling.Dimensions.HE as HEDimensions\nimport qualified Duckling.Dimensions.HI as HIDimensions\nimport qualified Duckling.Dimensions.HR as HRDimensions\nimport qualified Duckling.Dimensions.HU as HUDimensions\nimport qualified Duckling.Dimensions.ID as IDDimensions\nimport qualified Duckling.Dimensions.IS as ISDimensions\nimport qualified Duckling.Dimensions.IT as ITDimensions\nimport qualified Duckling.Dimensions.JA as JADimensions\nimport qualified Duckling.Dimensions.KA as KADimensions\nimport qualified Duckling.Dimensions.KM as KMDimensions\nimport qualified Duckling.Dimensions.KN as KNDimensions\nimport qualified Duckling.Dimensions.KO as KODimensions\nimport qualified Duckling.Dimensions.LO as LODimensions\nimport qualified Duckling.Dimensions.ML as MLDimensions\nimport qualified Duckling.Dimensions.MN as MNDimensions\nimport qualified Duckling.Dimensions.MY as MYDimensions\nimport qualified Duckling.Dimensions.NB as NBDimensions\nimport qualified Duckling.Dimensions.NE as NEDimensions\nimport qualified Duckling.Dimensions.NL as NLDimensions\nimport qualified Duckling.Dimensions.PL as PLDimensions\nimport qualified Duckling.Dimensions.PT as PTDimensions\nimport qualified Duckling.Dimensions.RO as RODimensions\nimport qualified Duckling.Dimensions.RU as RUDimensions\nimport qualified Duckling.Dimensions.SK as SKDimensions\nimport qualified Duckling.Dimensions.SV as SVDimensions\nimport qualified Duckling.Dimensions.SW as SWDimensions\nimport qualified Duckling.Dimensions.TA as TADimensions\nimport qualified Duckling.Dimensions.TE as TEDimensions\nimport qualified Duckling.Dimensions.TH as THDimensions\nimport qualified Duckling.Dimensions.TR as TRDimensions\nimport qualified Duckling.Dimensions.UK as UKDimensions\nimport qualified Duckling.Dimensions.VI as VIDimensions\nimport qualified Duckling.Dimensions.ZH as ZHDimensions\n\n\nallDimensions :: Lang -> [Seal Dimension]\nallDimensions lang = CommonDimensions.allDimensions ++ langDimensions lang\n\n-- | Augments `targets` with all dependent dimensions.\nexplicitDimensions :: HashSet (Seal Dimension) -> HashSet (Seal Dimension)\nexplicitDimensions targets = HashSet.union targets deps\n where\n deps = HashSet.unions . map dependents $ HashSet.toList targets\n\n-- | Ordinal depends on Numeral for JA, KO, and ZH.\ndependents :: Seal Dimension -> HashSet (Seal Dimension)\ndependents (Seal CreditCardNumber) = HashSet.empty\ndependents (Seal Distance) = HashSet.singleton (Seal Numeral)\ndependents (Seal Duration) = HashSet.fromList [Seal Numeral, Seal TimeGrain]\ndependents (Seal Numeral) = HashSet.empty\ndependents (Seal Email) = HashSet.empty\ndependents (Seal AmountOfMoney) = HashSet.singleton (Seal Numeral)\ndependents (Seal Ordinal) = HashSet.singleton (Seal Numeral)\ndependents (Seal PhoneNumber) = HashSet.empty\ndependents (Seal Quantity) = HashSet.singleton (Seal Numeral)\ndependents (Seal RegexMatch) = HashSet.empty\ndependents (Seal Temperature) = HashSet.singleton (Seal Numeral)\ndependents (Seal Time) =\n HashSet.fromList [Seal Numeral, Seal Duration, Seal Ordinal, Seal TimeGrain]\ndependents (Seal TimeGrain) = HashSet.empty\ndependents (Seal Url) = HashSet.empty\ndependents (Seal Volume) = HashSet.singleton (Seal Numeral)\ndependents (Seal (CustomDimension dim)) = dimDependents dim\n\nlangDimensions :: Lang -> [Seal Dimension]\nlangDimensions AF = AFDimensions.allDimensions\nlangDimensions AR = ARDimensions.allDimensions\nlangDimensions BG = BGDimensions.allDimensions\nlangDimensions BN = BNDimensions.allDimensions\nlangDimensions CA = CADimensions.allDimensions\nlangDimensions CS = CSDimensions.allDimensions\nlangDimensions DA = DADimensions.allDimensions\nlangDimensions DE = DEDimensions.allDimensions\nlangDimensions EL = ELDimensions.allDimensions\nlangDimensions EN = ENDimensions.allDimensions\nlangDimensions ES = ESDimensions.allDimensions\nlangDimensions ET = ETDimensions.allDimensions\nlangDimensions FA = FADimensions.allDimensions\nlangDimensions FI = FIDimensions.allDimensions\nlangDimensions FR = FRDimensions.allDimensions\nlangDimensions GA = GADimensions.allDimensions\nlangDimensions HE = HEDimensions.allDimensions\nlangDimensions HI = HIDimensions.allDimensions\nlangDimensions HR = HRDimensions.allDimensions\nlangDimensions HU = HUDimensions.allDimensions\nlangDimensions ID = IDDimensions.allDimensions\nlangDimensions IS = ISDimensions.allDimensions\nlangDimensions IT = ITDimensions.allDimensions\nlangDimensions JA = JADimensions.allDimensions\nlangDimensions KA = KADimensions.allDimensions\nlangDimensions KM = KMDimensions.allDimensions\nlangDimensions KN = KNDimensions.allDimensions\nlangDimensions KO = KODimensions.allDimensions\nlangDimensions LO = LODimensions.allDimensions\nlangDimensions ML = MLDimensions.allDimensions\nlangDimensions MN = MNDimensions.allDimensions\nlangDimensions MY = MYDimensions.allDimensions\nlangDimensions NB = NBDimensions.allDimensions\nlangDimensions NE = NEDimensions.allDimensions\nlangDimensions NL = NLDimensions.allDimensions\nlangDimensions PL = PLDimensions.allDimensions\nlangDimensions PT = PTDimensions.allDimensions\nlangDimensions RO = RODimensions.allDimensions\nlangDimensions RU = RUDimensions.allDimensions\nlangDimensions SK = SKDimensions.allDimensions\nlangDimensions SV = SVDimensions.allDimensions\nlangDimensions SW = SWDimensions.allDimensions\nlangDimensions TA = TADimensions.allDimensions\nlangDimensions TE = TEDimensions.allDimensions\nlangDimensions TH = THDimensions.allDimensions\nlangDimensions TR = TRDimensions.allDimensions\nlangDimensions UK = UKDimensions.allDimensions\nlangDimensions VI = VIDimensions.allDimensions\nlangDimensions ZH = ZHDimensions.allDimensions\n", "num_lines": 154} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE NamedFieldPuns #-}\n{-# LANGUAGE NoRebindableSyntax #-}\n\nmodule Duckling.Engine\n ( parseAndResolve\n , lookupRegexAnywhere\n , runDuckling\n ) where\n\nimport Control.DeepSeq\nimport Control.Monad.Extra\nimport Data.ByteString (ByteString)\nimport Data.Functor.Identity\nimport Data.Maybe\nimport Data.Text (Text)\nimport Prelude\nimport qualified Data.Array as Array\nimport qualified Data.Foldable as Foldable\nimport qualified Data.List as L\nimport qualified Text.Regex.PCRE as PCRE\n\nimport Duckling.Dimensions.Types\nimport Duckling.Locale\nimport Duckling.Regex.Types\nimport Duckling.Resolve\nimport Duckling.Types hiding (regex)\nimport Duckling.Types.Document (Document)\nimport Duckling.Types.Stash (Stash)\nimport qualified Duckling.Engine.Regex as Regex\nimport qualified Duckling.Types.Document as Document\nimport qualified Duckling.Types.Stash as Stash\n\n-- -----------------------------------------------------------------\n-- Engine\n\nparseAndResolve :: [Rule] -> Text -> Context -> Options -> [ResolvedToken]\nparseAndResolve rules input context@Context{locale = Locale lang _} options =\n mapMaybe\n (resolveNode context options)\n $ force $ Stash.toPosOrderedList\n $ runDuckling $ parseString lang rules (Document.fromText input)\n\ntype Duckling a = Identity a\n\nrunDuckling :: Duckling a -> a\nrunDuckling ma = runIdentity ma\n\n-- | A match is full if its rule pattern is empty.\n-- (rule, endPosition, reversedRoute)\ntype Match = (Rule, Int, [Node])\n\nresolveNode :: Context -> Options -> Node -> Maybe ResolvedToken\nresolveNode context options n@Node{token = (Token dim dd), nodeRange = r}\n = do\n (val, latent) <- resolve context options dd\n Just Resolved\n { range = r\n , node = n\n , rval = RVal dim val\n , isLatent = latent\n }\n\nparseString :: Lang -> [Rule] -> Document -> Duckling Stash\nparseString lang rules sentence = do\n (new, partialMatches) <-\n -- One the first pass we try all the rules\n parseString1 lang rules sentence Stash.empty Stash.empty []\n if Stash.null new\n then return Stash.empty\n else\n -- For subsequent passes, we only try rules starting with a predicate.\n saturateParseString lang headPredicateRules sentence new new partialMatches\n where\n headPredicateRules =\n [ rule | rule@Rule{pattern = (Predicate _ : _)} <- rules ]\n\n-- | Produces all tokens recursively.\nsaturateParseString\n :: Lang -> [Rule] -> Document -> Stash -> Stash -> [Match] -> Duckling Stash\nsaturateParseString lang rules sentence stash new matches = do\n (new', matches') <- parseString1 lang rules sentence stash new matches\n let stash' = Stash.union stash new'\n if Stash.null new'\n then return stash\n else saturateParseString lang rules sentence stash' new' matches'\n\n-- | Finds new matches resulting from newly added tokens.\n-- Produces new tokens from full matches.\nparseString1\n :: Lang -> [Rule] -> Document -> Stash -> Stash -> [Match]\n -> Duckling (Stash, [Match])\nparseString1 lang rules sentence stash new matches = do\n -- Recursively match patterns.\n -- Find which `matches` can advance because of `new`.\n newPartial <- concatMapM (matchFirst sentence lang new) matches\n\n -- Find new matches resulting from newly added tokens (`new`)\n newMatches <- concatMapM (matchFirstAnywhere sentence lang new) rules\n\n (full, partial) <- L.partition (\\(Rule {pattern}, _, _) -> null pattern)\n <$> matchAll sentence lang stash (newPartial ++ newMatches)\n\n -- Produce full matches as new tokens\n return ( Stash.fromList $ mapMaybe produce full\n , partial ++ matches\n )\n\n-- | Recursively augments `matches`.\n-- Discards partial matches stuck by a regex.\nmatchAll :: Document -> Lang -> Stash -> [Match] -> Duckling [Match]\nmatchAll sentence lang stash matches = concatMapM mkNextMatches matches\n where\n mkNextMatches :: Match -> Duckling [Match]\n mkNextMatches match@(Rule {pattern = []}, _, _) = return [ match ]\n mkNextMatches match@(Rule {pattern = p:_}, _, _) = do\n nextMatches <- matchAll sentence lang stash =<< matchFirst sentence lang stash match\n return $ case p of\n Regex _ -> nextMatches\n Predicate _ -> match:nextMatches\n\nproduce :: Match -> Maybe Node\nproduce (_, _, []) = Nothing\nproduce (Rule name _ production, _, etuor@(Node {nodeRange = Range _ e}:_)) = do\n let route = reverse etuor\n token <- force $ production $ map token route\n case route of\n (Node {nodeRange = Range p _}:_) -> Just Node\n { nodeRange = Range p e\n , token = token\n , children = route\n , rule = Just name\n }\n [] -> Nothing\n\n-- | Returns all matches matching the first pattern item of `match`,\n-- resuming from a Match position\nmatchFirst :: Document -> Lang -> Stash -> Match -> Duckling [Match]\nmatchFirst _ _ _ (Rule {pattern = []}, _, _) = return []\nmatchFirst sentence lang stash (rule@Rule{pattern = p : ps}, position, route) =\n map (mkMatch route newRule) <$> lookupItem sentence lang p stash position\n where\n newRule = rule { pattern = ps }\n\n-- | Returns all matches matching the first pattern item of `match`,\n-- starting anywhere\nmatchFirstAnywhere :: Document -> Lang -> Stash -> Rule -> Duckling [Match]\nmatchFirstAnywhere _sentence _lang _stash Rule {pattern = []} = return []\nmatchFirstAnywhere sentence lang stash rule@Rule{pattern = p : ps} =\n map (mkMatch [] newRule) <$> lookupItemAnywhere sentence lang p stash\n where\n newRule = rule { pattern = ps }\n\n-- | Handle one PatternItem at a given position\nlookupItem :: Document -> Lang -> PatternItem -> Stash -> Int -> Duckling [Node]\nlookupItem doc lang (Regex re) _ position =\n filter (isPositionValid position doc) <$>\n lookupRegex doc lang re position\nlookupItem doc _lang (Predicate p) stash position =\n return $\n filter (p . token) $\n takeWhile (isPositionValid position doc) $\n Stash.toPosOrderedListFrom stash position\n\n-- | Handle one PatternItem anywhere in the text\nlookupItemAnywhere :: Document -> Lang -> PatternItem -> Stash -> Duckling [Node]\nlookupItemAnywhere doc lang (Regex re) _ = lookupRegexAnywhere doc lang re\nlookupItemAnywhere _doc _lang (Predicate p) stash =\n return $ filter (p . token) $ Stash.toPosOrderedList stash\n\nisPositionValid :: Int -> Document -> Node -> Bool\nisPositionValid position sentence Node{nodeRange = Range start _} =\n Document.isAdjacent sentence position start\n\n{-# INLINE mkMatch #-}\nmkMatch :: [Node] -> Rule -> Node -> Match\nmkMatch route newRule node@Node{nodeRange = Range _ pos'} =\n newRoute `seq` (newRule, pos', newRoute)\n where newRoute = node:route\n\n-- | Handle a regex match at a given position\nlookupRegex :: Document -> Lang -> PCRE.Regex -> Int -> Duckling [Node]\nlookupRegex doc _lang _regex position | position >= Document.length doc = return []\nlookupRegex doc lang regex position =\n lookupRegexCommon doc lang regex position Regex.matchOnce\n\n-- | Handle a regex match anywhere in the text\nlookupRegexAnywhere :: Document -> Lang -> PCRE.Regex -> Duckling [Node]\nlookupRegexAnywhere doc lang regex = lookupRegexCommon doc lang regex 0 Regex.matchAll\n\n{-# INLINE lookupRegexCommon #-}\n-- INLINE bloats the code a bit, but the code is better\nlookupRegexCommon\n :: Foldable t\n => Document\n -> Lang\n -> PCRE.Regex\n -> Int\n -> (PCRE.Regex -> ByteString -> t PCRE.MatchArray)\n -> Duckling [Node]\nlookupRegexCommon doc lang regex position matchFun = return nodes\n where\n -- See Note [Regular expressions and Text] from Document.hs to understand\n -- what's going on here\n (substring, rangeToText, translateRange) =\n Document.byteStringFromPos doc position\n nodes = mapMaybe (f . Array.elems)\n $ Foldable.toList\n $ matchFun regex substring\n f :: [(Int, Int)] -> Maybe Node\n f [] = Nothing\n f ((0,0):_) = Nothing\n f ((bsStart, bsLen):groups) =\n if Document.isRangeValid lang doc start end\n then Just node\n else Nothing\n where\n textGroups = map rangeToText groups\n (start, end) = translateRange bsStart bsLen\n node = Node\n { nodeRange = Range start end\n , token = Token RegexMatch (GroupMatch textGroups)\n , children = []\n , rule = Nothing\n }\n", "num_lines": 232} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE DeriveAnyClass #-}\n{-# LANGUAGE DeriveGeneric #-}\n{-# LANGUAGE NoRebindableSyntax #-}\nmodule Duckling.Locale\n ( Lang(..)\n , Locale(..)\n , Region\n ( AU\n , BE\n , BZ\n , CL\n , CN\n , CO\n , EG\n , GB\n , HK\n , IE\n , IN\n , JM\n , MO\n , MX\n , NZ\n , PE\n , PH\n , TT\n , TW\n , US\n , VE\n , ZA\n )\n , allLocales\n , makeLocale\n ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport qualified Data.HashMap.Strict as HashMap\nimport Data.HashSet (HashSet)\nimport qualified Data.HashSet as HashSet\nimport Data.Hashable\nimport GHC.Generics\nimport Prelude\nimport TextShow (TextShow)\nimport qualified TextShow as TS\n\nimport Duckling.Region hiding\n ( AR\n , CA\n , ES\n , NL\n )\nimport qualified Duckling.Region as R\n ( Region\n ( AR\n , CA\n , ES\n , NL\n )\n )\n\n-- | ISO 639-1 Language.\n-- See https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes\ndata Lang\n = AF\n | AR\n | BG\n | BN\n | CA\n | CS\n | DA\n | DE\n | EL\n | EN\n | ES\n | ET\n | FA\n | FI\n | FR\n | GA\n | HE\n | HI\n | HR\n | HU\n | ID\n | IS\n | IT\n | JA\n | KA\n | KN\n | KM\n | KO\n | LO\n | ML\n | MN\n | MY\n | NB\n | NE\n | NL\n | PL\n | PT\n | RO\n | RU\n | SK\n | SV\n | SW\n | TA\n | TE\n | TH\n | TR\n | UK\n | VI\n | ZH\n deriving (Bounded, Enum, Eq, Generic, Hashable, Ord, Read, Show)\n\ninstance TextShow Lang where\n showb = TS.fromString . show\n\ndata Locale = Locale Lang (Maybe Region)\n deriving (Eq, Generic, Hashable, Ord)\n\ninstance Show Locale where\n show (Locale lang Nothing) = show lang ++ \"_XX\"\n show (Locale lang (Just region)) = show lang ++ \"_\" ++ show region\n\ninstance TextShow Locale where\n showb = TS.fromString . show\n\nmakeLocale :: Lang -> Maybe Region -> Locale\nmakeLocale lang Nothing = Locale lang Nothing\nmakeLocale lang (Just region)\n | HashSet.member region locales = Locale lang $ Just region\n | otherwise = Locale lang Nothing\n where\n locales = HashMap.lookupDefault HashSet.empty lang allLocales\n\nallLocales :: HashMap Lang (HashSet Region)\nallLocales =\n HashMap.fromList\n [ (AR, HashSet.fromList [EG])\n , (EN, HashSet.fromList [AU, BZ, R.CA, GB, IN, IE, JM, NZ, PH, ZA, TT, US])\n , (ES, HashSet.fromList [R.AR, CL, CO, R.ES, MX, PE, VE])\n , (NL, HashSet.fromList [BE, R.NL])\n , (ZH, HashSet.fromList [CN, HK, MO, TW])\n ]\n", "num_lines": 151} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE DeriveAnyClass #-}\n{-# LANGUAGE DeriveGeneric #-}\n{-# LANGUAGE NoRebindableSyntax #-}\n\nmodule Duckling.Region\n ( Region(..)\n ) where\n\nimport Data.Hashable\nimport GHC.Generics\nimport Prelude\nimport TextShow (TextShow)\nimport qualified TextShow as TS\n\n-- | ISO 3166-1 alpha-2 Country code (includes regions and territories).\n-- See https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2\ndata Region\n = AR\n | AU\n | BE\n | BZ\n | CA\n | CL\n | CN\n | CO\n | EG\n | ES\n | GB\n | HK\n | IE\n | IN\n | JM\n | MN\n | MX\n | MO\n | NL\n | NZ\n | PE\n | PH\n | TT\n | TW\n | US\n | VE\n | ZA\n deriving (Bounded, Enum, Eq, Generic, Hashable, Ord, Read, Show)\n\ninstance TextShow Region where\n showb = TS.fromString . show\n", "num_lines": 56} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE FlexibleContexts #-}\n{-# LANGUAGE TypeFamilies #-}\n\nmodule Duckling.Resolve\n ( Context(..)\n , DucklingTime(..)\n , Options(..)\n , Resolve(..)\n , fromUTC\n , toUTC\n ) where\n\nimport Data.Aeson (ToJSON)\nimport Prelude\nimport qualified Data.Time as Time\nimport qualified Data.Time.LocalTime.TimeZone.Series as Series\n\nimport Duckling.Locale\n\n-- | Internal time reference.\n-- We work as if we were in UTC time and use `ZoneSeriesTime` to house the info.\n-- We convert to local time at resolution, using `fromUTC`.\nnewtype DucklingTime = DucklingTime Series.ZoneSeriesTime\n deriving (Eq, Show)\n\ndata Context = Context\n { referenceTime :: DucklingTime\n , locale :: Locale\n }\n deriving (Eq, Show)\n\nnewtype Options = Options\n { withLatent :: Bool -- When set, includes less certain parses, e.g. \"7\" as an hour of the day\n }\n deriving (Eq, Show)\n\nclass ( Eq (ResolvedValue a)\n , Show (ResolvedValue a)\n , ToJSON (ResolvedValue a)\n ) => Resolve a where\n type ResolvedValue a\n resolve :: Context -> Options -> a -> Maybe (ResolvedValue a, Bool)\n\n-- | Given a UTCTime and an TimeZone, build a ZonedTime (no conversion)\nfromUTC :: Time.UTCTime -> Time.TimeZone -> Time.ZonedTime\nfromUTC (Time.UTCTime day diffTime) timeZone = Time.ZonedTime localTime timeZone\n where\n localTime = Time.LocalTime day timeOfDay\n timeOfDay = Time.timeToTimeOfDay diffTime\n\n-- | Given a LocalTime, build a UTCTime (no conversion)\ntoUTC :: Time.LocalTime -> Time.UTCTime\ntoUTC (Time.LocalTime day timeOfDay) = Time.UTCTime day diffTime\n where\n diffTime = Time.timeOfDayToTime timeOfDay\n", "num_lines": 63} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE NoRebindableSyntax #-}\n\nmodule Duckling.Rules\n ( allRules\n , rulesFor\n ) where\n\nimport Data.HashSet (HashSet)\nimport Prelude\nimport qualified Data.HashSet as HashSet\n\nimport Duckling.Dimensions\nimport Duckling.Dimensions.Types\nimport Duckling.Locale\nimport Duckling.Types\nimport qualified Duckling.Rules.AF as AFRules\nimport qualified Duckling.Rules.AR as ARRules\nimport qualified Duckling.Rules.Common as CommonRules\nimport qualified Duckling.Rules.BG as BGRules\nimport qualified Duckling.Rules.BN as BNRules\nimport qualified Duckling.Rules.CA as CARules\nimport qualified Duckling.Rules.CS as CSRules\nimport qualified Duckling.Rules.DA as DARules\nimport qualified Duckling.Rules.DE as DERules\nimport qualified Duckling.Rules.EL as ELRules\nimport qualified Duckling.Rules.EN as ENRules\nimport qualified Duckling.Rules.ES as ESRules\nimport qualified Duckling.Rules.ET as ETRules\nimport qualified Duckling.Rules.FI as FIRules\nimport qualified Duckling.Rules.FA as FARules\nimport qualified Duckling.Rules.FR as FRRules\nimport qualified Duckling.Rules.GA as GARules\nimport qualified Duckling.Rules.HE as HERules\nimport qualified Duckling.Rules.HI as HIRules\nimport qualified Duckling.Rules.HR as HRRules\nimport qualified Duckling.Rules.HU as HURules\nimport qualified Duckling.Rules.ID as IDRules\nimport qualified Duckling.Rules.IS as ISRules\nimport qualified Duckling.Rules.IT as ITRules\nimport qualified Duckling.Rules.JA as JARules\nimport qualified Duckling.Rules.KA as KARules\nimport qualified Duckling.Rules.KM as KMRules\nimport qualified Duckling.Rules.KN as KNRules\nimport qualified Duckling.Rules.KO as KORules\nimport qualified Duckling.Rules.LO as LORules\nimport qualified Duckling.Rules.ML as MLRules\nimport qualified Duckling.Rules.MN as MNRules\nimport qualified Duckling.Rules.MY as MYRules\nimport qualified Duckling.Rules.NB as NBRules\nimport qualified Duckling.Rules.NE as NERules\nimport qualified Duckling.Rules.NL as NLRules\nimport qualified Duckling.Rules.PL as PLRules\nimport qualified Duckling.Rules.PT as PTRules\nimport qualified Duckling.Rules.RO as RORules\nimport qualified Duckling.Rules.RU as RURules\nimport qualified Duckling.Rules.SK as SKRules\nimport qualified Duckling.Rules.SV as SVRules\nimport qualified Duckling.Rules.SW as SWRules\nimport qualified Duckling.Rules.TA as TARules\nimport qualified Duckling.Rules.TE as TERules\nimport qualified Duckling.Rules.TH as THRules\nimport qualified Duckling.Rules.TR as TRRules\nimport qualified Duckling.Rules.UK as UKRules\nimport qualified Duckling.Rules.VI as VIRules\nimport qualified Duckling.Rules.ZH as ZHRules\n\n-- | Returns the minimal set of rules required for `targets`.\nrulesFor :: Locale -> HashSet (Seal Dimension) -> [Rule]\nrulesFor locale targets\n | HashSet.null targets = allRules locale\n | otherwise = [ rules | dims <- HashSet.toList $ explicitDimensions targets\n , rules <- rulesFor' locale dims ]\n\n-- | Returns all the rules for the provided locale.\n-- We can't really use `allDimensions` as-is, since `TimeGrain` is not present.\nallRules :: Locale -> [Rule]\nallRules locale@(Locale lang _) = concatMap (rulesFor' locale) . HashSet.toList\n . explicitDimensions . HashSet.fromList $ allDimensions lang\n\nrulesFor' :: Locale -> Seal Dimension -> [Rule]\nrulesFor' (Locale lang (Just region)) dim =\n CommonRules.rules dim ++ langRules lang dim ++ localeRules lang region dim\nrulesFor' (Locale lang Nothing) dim =\n CommonRules.rules dim ++ defaultRules lang dim\n\n-- | Default rules when no locale, for backward compatibility.\ndefaultRules :: Lang -> Seal Dimension -> [Rule]\ndefaultRules AF = AFRules.defaultRules\ndefaultRules AR = ARRules.defaultRules\ndefaultRules BG = BGRules.defaultRules\ndefaultRules BN = BNRules.defaultRules\ndefaultRules CA = CARules.defaultRules\ndefaultRules CS = CSRules.defaultRules\ndefaultRules DA = DARules.defaultRules\ndefaultRules DE = DERules.defaultRules\ndefaultRules EL = ELRules.defaultRules\ndefaultRules EN = ENRules.defaultRules\ndefaultRules ES = ESRules.defaultRules\ndefaultRules ET = ETRules.defaultRules\ndefaultRules FI = FIRules.defaultRules\ndefaultRules FA = FARules.defaultRules\ndefaultRules FR = FRRules.defaultRules\ndefaultRules GA = GARules.defaultRules\ndefaultRules HE = HERules.defaultRules\ndefaultRules HI = HIRules.defaultRules\ndefaultRules HR = HRRules.defaultRules\ndefaultRules HU = HURules.defaultRules\ndefaultRules ID = IDRules.defaultRules\ndefaultRules IS = ISRules.defaultRules\ndefaultRules IT = ITRules.defaultRules\ndefaultRules JA = JARules.defaultRules\ndefaultRules KA = KARules.defaultRules\ndefaultRules KM = KMRules.defaultRules\ndefaultRules KN = KNRules.defaultRules\ndefaultRules KO = KORules.defaultRules\ndefaultRules LO = LORules.defaultRules\ndefaultRules ML = MLRules.defaultRules\ndefaultRules MN = MNRules.defaultRules\ndefaultRules MY = MYRules.defaultRules\ndefaultRules NB = NBRules.defaultRules\ndefaultRules NE = NERules.defaultRules\ndefaultRules NL = NLRules.defaultRules\ndefaultRules PL = PLRules.defaultRules\ndefaultRules PT = PTRules.defaultRules\ndefaultRules RO = RORules.defaultRules\ndefaultRules RU = RURules.defaultRules\ndefaultRules SK = SKRules.defaultRules\ndefaultRules SV = SVRules.defaultRules\ndefaultRules SW = SWRules.defaultRules\ndefaultRules TA = TARules.defaultRules\ndefaultRules TE = TERules.defaultRules\ndefaultRules TH = THRules.defaultRules\ndefaultRules TR = TRRules.defaultRules\ndefaultRules UK = UKRules.defaultRules\ndefaultRules VI = VIRules.defaultRules\ndefaultRules ZH = ZHRules.defaultRules\n\nlocaleRules :: Lang -> Region -> Seal Dimension -> [Rule]\nlocaleRules AF = AFRules.localeRules\nlocaleRules AR = ARRules.localeRules\nlocaleRules BG = BGRules.localeRules\nlocaleRules BN = BNRules.localeRules\nlocaleRules CA = CARules.localeRules\nlocaleRules CS = CSRules.localeRules\nlocaleRules DA = DARules.localeRules\nlocaleRules DE = DERules.localeRules\nlocaleRules EL = ELRules.localeRules\nlocaleRules EN = ENRules.localeRules\nlocaleRules ES = ESRules.localeRules\nlocaleRules ET = ETRules.localeRules\nlocaleRules FI = FIRules.localeRules\nlocaleRules FA = FARules.localeRules\nlocaleRules FR = FRRules.localeRules\nlocaleRules GA = GARules.localeRules\nlocaleRules HE = HERules.localeRules\nlocaleRules HI = HIRules.localeRules\nlocaleRules HR = HRRules.localeRules\nlocaleRules HU = HURules.localeRules\nlocaleRules ID = IDRules.localeRules\nlocaleRules IS = ISRules.localeRules\nlocaleRules IT = ITRules.localeRules\nlocaleRules JA = JARules.localeRules\nlocaleRules KA = KARules.localeRules\nlocaleRules KM = KMRules.localeRules\nlocaleRules KN = KNRules.localeRules\nlocaleRules KO = KORules.localeRules\nlocaleRules LO = LORules.localeRules\nlocaleRules ML = MLRules.localeRules\nlocaleRules MN = MNRules.localeRules\nlocaleRules MY = MYRules.localeRules\nlocaleRules NB = NBRules.localeRules\nlocaleRules NE = NERules.localeRules\nlocaleRules NL = NLRules.localeRules\nlocaleRules PL = PLRules.localeRules\nlocaleRules PT = PTRules.localeRules\nlocaleRules RO = RORules.localeRules\nlocaleRules RU = RURules.localeRules\nlocaleRules SK = SKRules.localeRules\nlocaleRules SV = SVRules.localeRules\nlocaleRules SW = SWRules.localeRules\nlocaleRules TA = TARules.localeRules\nlocaleRules TE = TERules.localeRules\nlocaleRules TH = THRules.localeRules\nlocaleRules TR = TRRules.localeRules\nlocaleRules UK = UKRules.localeRules\nlocaleRules VI = VIRules.localeRules\nlocaleRules ZH = ZHRules.localeRules\n\nlangRules :: Lang -> Seal Dimension -> [Rule]\nlangRules AF = AFRules.langRules\nlangRules AR = ARRules.langRules\nlangRules BG = BGRules.langRules\nlangRules BN = BNRules.langRules\nlangRules CA = CARules.langRules\nlangRules CS = CSRules.langRules\nlangRules DA = DARules.langRules\nlangRules DE = DERules.langRules\nlangRules EL = ELRules.langRules\nlangRules EN = ENRules.langRules\nlangRules ES = ESRules.langRules\nlangRules ET = ETRules.langRules\nlangRules FI = FIRules.langRules\nlangRules FA = FARules.langRules\nlangRules FR = FRRules.langRules\nlangRules GA = GARules.langRules\nlangRules HE = HERules.langRules\nlangRules HI = HIRules.langRules\nlangRules KN = KNRules.langRules\nlangRules HR = HRRules.langRules\nlangRules HU = HURules.langRules\nlangRules ID = IDRules.langRules\nlangRules IS = ISRules.langRules\nlangRules IT = ITRules.langRules\nlangRules JA = JARules.langRules\nlangRules KA = KARules.langRules\nlangRules KM = KMRules.langRules\nlangRules KO = KORules.langRules\nlangRules LO = LORules.langRules\nlangRules ML = MLRules.langRules\nlangRules MN = MNRules.langRules\nlangRules MY = MYRules.langRules\nlangRules NB = NBRules.langRules\nlangRules NE = NERules.langRules\nlangRules NL = NLRules.langRules\nlangRules PL = PLRules.langRules\nlangRules PT = PTRules.langRules\nlangRules RO = RORules.langRules\nlangRules RU = RURules.langRules\nlangRules SK = SKRules.langRules\nlangRules SV = SVRules.langRules\nlangRules SW = SWRules.langRules\nlangRules TA = TARules.langRules\nlangRules TE = TERules.langRules\nlangRules TH = THRules.langRules\nlangRules TR = TRRules.langRules\nlangRules UK = UKRules.langRules\nlangRules VI = VIRules.langRules\nlangRules ZH = ZHRules.langRules\n", "num_lines": 247} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE AllowAmbiguousTypes #-}\n{-# LANGUAGE DeriveAnyClass #-}\n{-# LANGUAGE DeriveGeneric #-}\n{-# LANGUAGE ExistentialQuantification #-}\n{-# LANGUAGE FlexibleContexts #-}\n{-# LANGUAGE FlexibleInstances #-}\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE NoRebindableSyntax #-}\n{-# LANGUAGE OverloadedStrings #-}\n{-# LANGUAGE RankNTypes #-}\n{-# LANGUAGE ScopedTypeVariables #-}\n{-# LANGUAGE StandaloneDeriving #-}\n{-# LANGUAGE TypeFamilies #-}\n{-# LANGUAGE TypeOperators #-}\n{-# LANGUAGE NamedFieldPuns #-}\n\nmodule Duckling.Types where\n\nimport Control.DeepSeq\nimport Data.Aeson\nimport Data.GADT.Compare\nimport Data.GADT.Show\nimport Data.Hashable\nimport Data.HashMap.Strict (HashMap)\nimport Data.HashSet (HashSet)\nimport Data.List (intersperse, sortOn)\nimport Data.Maybe\nimport Data.Text (Text, toLower, unpack)\nimport Data.Typeable ((:~:)(Refl), eqT, Typeable)\nimport GHC.Generics\nimport Prelude\nimport TextShow (TextShow(..))\nimport qualified Data.ByteString.Lazy as LB\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as TT\nimport qualified Data.Text.Encoding as Text\nimport qualified Text.Regex.Base as R\nimport qualified Text.Regex.PCRE as PCRE\nimport qualified TextShow as TS\n\nimport Duckling.AmountOfMoney.Types (AmountOfMoneyData)\nimport Duckling.CreditCardNumber.Types (CreditCardNumberData)\nimport Duckling.Distance.Types (DistanceData)\nimport Duckling.Duration.Types (DurationData)\nimport Duckling.Email.Types (EmailData)\nimport Duckling.Locale\nimport Duckling.Numeral.Types (NumeralData)\nimport Duckling.Ordinal.Types (OrdinalData)\nimport Duckling.PhoneNumber.Types (PhoneNumberData)\nimport Duckling.Quantity.Types (QuantityData)\nimport Duckling.Regex.Types\nimport Duckling.Resolve\nimport Duckling.Temperature.Types (TemperatureData)\nimport Duckling.Time.Types (TimeData)\nimport Duckling.TimeGrain.Types (Grain)\nimport Duckling.Url.Types (UrlData)\nimport Duckling.Volume.Types (VolumeData)\n\n-- -----------------------------------------------------------------\n-- Token\n\ndata Token = forall a . (Resolve a, Eq a, Hashable a, Show a, NFData a) =>\n Token (Dimension a) a\n\nderiving instance Show Token\ninstance Eq Token where\n Token d1 v1 == Token d2 v2 = case geq d1 d2 of\n Just Refl -> v1 == v2\n Nothing -> False\n\ninstance Hashable Token where\n hashWithSalt s (Token d v) = hashWithSalt s (d, v)\n\ninstance NFData Token where\n rnf (Token _ v) = rnf v\n\n-- -----------------------------------------------------------------\n-- Seal\n\ndata Seal s where\n Seal :: s a -> Seal s\n\ninstance GEq s => Eq (Seal s) where\n Seal x == Seal y =\n defaultEq x y\n\ninstance GShow s => Show (Seal s) where\n showsPrec p (Seal s)\n = showParen (p > 10) (showString \"Seal \" . gshowsPrec 11 s)\n\nwithSeal :: Seal s -> (forall t. s t -> r) -> r\nwithSeal (Seal x) f = f x\n\n-- -----------------------------------------------------------------\n-- Dimension\n\nclass (Show a, Typeable a, Typeable (DimensionData a)) =>\n CustomDimension a where\n type DimensionData a\n dimRules :: a -> [Rule]\n dimLangRules :: Lang -> a -> [Rule]\n dimLocaleRules :: Region -> a -> [Rule]\n dimDependents :: a -> HashSet (Seal Dimension)\n\n-- | GADT for differentiating between dimensions\n-- Each dimension should have its own constructor and provide the data structure\n-- for its parsed data\ndata Dimension a where\n RegexMatch :: Dimension GroupMatch\n AmountOfMoney :: Dimension AmountOfMoneyData\n CreditCardNumber :: Dimension CreditCardNumberData\n Distance :: Dimension DistanceData\n Duration :: Dimension DurationData\n Email :: Dimension EmailData\n Numeral :: Dimension NumeralData\n Ordinal :: Dimension OrdinalData\n PhoneNumber :: Dimension PhoneNumberData\n Quantity :: Dimension QuantityData\n Temperature :: Dimension TemperatureData\n Time :: Dimension TimeData\n TimeGrain :: Dimension Grain\n Url :: Dimension UrlData\n Volume :: Dimension VolumeData\n CustomDimension :: CustomDimension a => a -> Dimension (DimensionData a)\n\n-- Show\ninstance Show (Dimension a) where\n show RegexMatch = \"RegexMatch\"\n show CreditCardNumber = \"CreditCardNumber\"\n show Distance = \"Distance\"\n show Duration = \"Duration\"\n show Email = \"Email\"\n show AmountOfMoney = \"AmountOfMoney\"\n show Numeral = \"Numeral\"\n show Ordinal = \"Ordinal\"\n show PhoneNumber = \"PhoneNumber\"\n show Quantity = \"Quantity\"\n show Temperature = \"Temperature\"\n show Time = \"Time\"\n show TimeGrain = \"TimeGrain\"\n show Url = \"Url\"\n show Volume = \"Volume\"\n show (CustomDimension d) = show d\ninstance GShow Dimension where gshowsPrec = showsPrec\n\n-- TextShow\ninstance TextShow (Dimension a) where\n showb d = TS.fromString $ show d\ninstance TextShow (Seal Dimension) where\n showb (Seal d) = showb d\n\n-- Hashable\ninstance Hashable (Seal Dimension) where\n hashWithSalt s (Seal a) = hashWithSalt s a\ninstance Hashable (Dimension a) where\n hashWithSalt s RegexMatch = hashWithSalt s (0::Int)\n hashWithSalt s Distance = hashWithSalt s (1::Int)\n hashWithSalt s Duration = hashWithSalt s (2::Int)\n hashWithSalt s Email = hashWithSalt s (3::Int)\n hashWithSalt s AmountOfMoney = hashWithSalt s (4::Int)\n hashWithSalt s Numeral = hashWithSalt s (5::Int)\n hashWithSalt s Ordinal = hashWithSalt s (6::Int)\n hashWithSalt s PhoneNumber = hashWithSalt s (7::Int)\n hashWithSalt s Quantity = hashWithSalt s (8::Int)\n hashWithSalt s Temperature = hashWithSalt s (9::Int)\n hashWithSalt s Time = hashWithSalt s (10::Int)\n hashWithSalt s TimeGrain = hashWithSalt s (11::Int)\n hashWithSalt s Url = hashWithSalt s (12::Int)\n hashWithSalt s Volume = hashWithSalt s (13::Int)\n hashWithSalt s (CustomDimension _) = hashWithSalt s (14::Int)\n hashWithSalt s CreditCardNumber = hashWithSalt s (15::Int)\n\ninstance GEq Dimension where\n geq RegexMatch RegexMatch = Just Refl\n geq RegexMatch _ = Nothing\n geq CreditCardNumber CreditCardNumber = Just Refl\n geq CreditCardNumber _ = Nothing\n geq Distance Distance = Just Refl\n geq Distance _ = Nothing\n geq Duration Duration = Just Refl\n geq Duration _ = Nothing\n geq Email Email = Just Refl\n geq Email _ = Nothing\n geq AmountOfMoney AmountOfMoney = Just Refl\n geq AmountOfMoney _ = Nothing\n geq Numeral Numeral = Just Refl\n geq Numeral _ = Nothing\n geq Ordinal Ordinal = Just Refl\n geq Ordinal _ = Nothing\n geq PhoneNumber PhoneNumber = Just Refl\n geq PhoneNumber _ = Nothing\n geq Quantity Quantity = Just Refl\n geq Quantity _ = Nothing\n geq Temperature Temperature = Just Refl\n geq Temperature _ = Nothing\n geq Time Time = Just Refl\n geq Time _ = Nothing\n geq TimeGrain TimeGrain = Just Refl\n geq TimeGrain _ = Nothing\n geq Url Url = Just Refl\n geq Url _ = Nothing\n geq Volume Volume = Just Refl\n geq Volume _ = Nothing\n geq (CustomDimension (_ :: a)) (CustomDimension (_ :: b))\n | Just Refl <- eqT :: Maybe (a :~: b) = Just Refl\n geq (CustomDimension _) _ = Nothing\n\nisDimension :: Dimension a -> Token -> Bool\nisDimension dim (Token dim' _) = isJust $ geq dim dim'\n\ndata ResolvedVal\n = forall a . ( Resolve a, Eq (ResolvedValue a)\n , Show (ResolvedValue a)\n , ToJSON (ResolvedValue a)) =>\n RVal (Dimension a) (ResolvedValue a)\n\nderiving instance Show ResolvedVal\n\ninstance Eq ResolvedVal where\n RVal d1 v1 == RVal d2 v2\n | Just Refl <- geq d1 d2 = v1 == v2\n | otherwise = False\n\ndata Node = Node\n { nodeRange :: Range\n , token :: Token\n , children :: [Node]\n , rule :: Maybe Text\n } deriving (Eq, Generic, Hashable, Show, NFData)\n\ndata ResolvedToken = Resolved\n { range :: Range\n , node :: Node\n , rval :: ResolvedVal\n , isLatent :: Bool\n } deriving (Eq, Show)\n\ninstance Ord ResolvedToken where\n compare (Resolved range1 _ (RVal _ v1) latent1)\n (Resolved range2 _ (RVal _ v2) latent2) =\n case compare range1 range2 of\n EQ -> case compare (toJText v1) (toJText v2) of\n EQ -> compare latent1 latent2\n z -> z\n z -> z\n\n\ndata Range = Range Int Int\n deriving (Eq, Ord, Generic, Hashable, Show, NFData)\n\ntype Production = [Token] -> Maybe Token\ntype Predicate = Token -> Bool\ndata PatternItem = Regex PCRE.Regex | Predicate Predicate\n\ntype Pattern = [PatternItem]\n\ndata Rule = Rule\n { name :: Text\n , pattern :: Pattern\n , prod :: Production\n }\n\ninstance Show Rule where\n show Rule{ name } = show name\n\ndata Entity = Entity\n { dim :: Text\n , body :: Text\n , value :: ResolvedVal\n , start :: Int\n , end :: Int\n , latent :: Bool\n , enode :: Node\n } deriving (Eq, Generic, Show)\n\ninstance ToJSON Entity where\n toJSON ent@Entity{value = RVal _ val} = object\n [ \"dim\" .= dim ent\n , \"body\" .= body ent\n , \"value\" .= val\n , \"start\" .= start ent\n , \"end\" .= end ent\n , \"latent\" .= latent ent\n ]\n\ntoJText :: ToJSON x => x -> Text\ntoJText = Text.decodeUtf8 . LB.toStrict . encode\n\n-- -----------------------------------------------------------------\n-- Predicates helpers\n\nregex :: String -> PatternItem\nregex = Regex . R.makeRegexOpts compOpts execOpts\n where\n compOpts = PCRE.defaultCompOpt + PCRE.compCaseless + PCRE.compUTF8\n execOpts = PCRE.defaultExecOpt\n\ndimension :: Typeable a => Dimension a -> PatternItem\ndimension d = Predicate $ isDimension d\n\n-- -----------------------------------------------------------------\n-- Rule Construction helpers\n\nsingleStringLookupRule :: HashMap Text a -> Text -> (a -> Maybe Token) -> Rule\nsingleStringLookupRule hashMap name production = Rule\n { name\n , pattern = [ regex $ unpack regexString ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (toLower match) hashMap >>= production\n _ -> Nothing\n }\n where\n regexString =\n \"(\" <> mconcat\n (intersperse \"|\" $ sortOn (negate . TT.length) $ HashMap.keys hashMap)\n <> \")\"\n", "num_lines": 326} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE NamedFieldPuns #-}\n\nmodule Duckling.AmountOfMoney.Helpers\n ( currencyOnly\n , valueOnly\n , isSimpleAmountOfMoney\n , isCent\n , isCents\n , isDollarCoin\n , isCurrencyOnly\n , isDime\n , isMoneyWithValue\n , isWithoutCents\n , withCents\n , withInterval\n , withMax\n , withMin\n , withValue\n , mkLatent\n , dollarCoins\n )\n where\n\nimport Data.HashMap.Strict (HashMap)\nimport Data.Maybe (isJust)\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\n\nimport Duckling.AmountOfMoney.Types\n ( Currency (..)\n , AmountOfMoneyData (..)\n , amountOfMoneyData'\n )\nimport Duckling.Numeral.Types (getIntValue, isInteger)\nimport Duckling.Dimensions.Types\nimport Duckling.Types hiding (Entity(..))\n\nimport qualified Data.HashMap.Strict as HashMap\n\n-- -----------------------------------------------------------------\n-- Dollar coin Types\n\ndollarCoins :: HashMap Text Double\ndollarCoins = HashMap.fromList\n [ (\"nickel\", 0.05)\n , (\"nickels\", 0.05)\n , (\"dime\", 0.1)\n , (\"dimes\", 0.1)\n , (\"quarter\", 0.25)\n , (\"quarters\", 0.25)\n ]\n\n-- -----------------------------------------------------------------\n-- Patterns\n\nisCents :: Predicate\nisCents (Token AmountOfMoney AmountOfMoneyData{value = Just _, currency = Cent}) = True\nisCents _ = False\n\nisWithoutCents :: Predicate\nisWithoutCents (Token AmountOfMoney AmountOfMoneyData{currency = Cent}) = False\nisWithoutCents (Token AmountOfMoney AmountOfMoneyData{value = Just v}) = isInteger v\nisWithoutCents _ = False\n\nisMoneyWithValue :: Predicate\nisMoneyWithValue (Token AmountOfMoney AmountOfMoneyData{value = v1, minValue = v2, maxValue = v3}) =\n any isJust [v1, v2, v3]\nisMoneyWithValue _ = False\n\nisCurrencyOnly :: Predicate\nisCurrencyOnly (Token AmountOfMoney AmountOfMoneyData\n {value = Nothing, minValue = Nothing, maxValue = Nothing}) = True\nisCurrencyOnly _ = False\n\nisDollarCoin :: Predicate\nisDollarCoin (Token AmountOfMoney AmountOfMoneyData{value = Just d, currency}) =\n elem d [0.05, 0.1, 0.25] && elem currency [Dollar, AUD, CAD, JMD,\n NZD, SGD, TTD, USD]\nisDollarCoin _ = False\n\nisSimpleAmountOfMoney :: Predicate\nisSimpleAmountOfMoney (Token AmountOfMoney AmountOfMoneyData\n {value = Just _, minValue = Nothing, maxValue = Nothing}) = True\nisSimpleAmountOfMoney _ = False\n\nisDime :: Predicate\nisDime (Token AmountOfMoney AmountOfMoneyData\n {value = Just d, currency = Cent}) =\n maybe False (\\i -> (i `mod` 10) == 0) $ getIntValue d\nisDime _ = False\n\nisCent :: Predicate\nisCent (Token AmountOfMoney AmountOfMoneyData\n {value = Just c, currency = Cent}) =\n maybe False (\\i -> i >= 0 && i <= 9) $ getIntValue c\nisCent _ = False\n\n-- -----------------------------------------------------------------\n-- Production\n\ncurrencyOnly :: Currency -> AmountOfMoneyData\ncurrencyOnly c = amountOfMoneyData'{currency = c}\n\nvalueOnly :: Double -> AmountOfMoneyData\nvalueOnly x = amountOfMoneyData'{value = Just x}\n\nwithValue :: Double -> AmountOfMoneyData -> AmountOfMoneyData\nwithValue x fd = fd {value = Just x}\n\nwithCents :: Double -> AmountOfMoneyData -> AmountOfMoneyData\nwithCents x fd@AmountOfMoneyData {value = Just value} = fd\n {value = Just $ value + x / 100}\nwithCents x AmountOfMoneyData {value = Nothing} =\n amountOfMoneyData'{value = Just x, currency = Cent}\n\nwithInterval :: (Double, Double) -> AmountOfMoneyData -> AmountOfMoneyData\nwithInterval (from, to) fd = fd\n {minValue = Just from, maxValue = Just to, value = Nothing}\n\nwithMin :: Double -> AmountOfMoneyData -> AmountOfMoneyData\nwithMin x fd = fd {minValue = Just x}\n\nwithMax :: Double -> AmountOfMoneyData -> AmountOfMoneyData\nwithMax x fd = fd {maxValue = Just x}\n\nmkLatent :: AmountOfMoneyData -> AmountOfMoneyData\nmkLatent fd = fd {latent = True}\n", "num_lines": 137} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.Rules\n ( rules\n ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport Data.Maybe\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\n\nimport Duckling.AmountOfMoney.Helpers\nimport Duckling.AmountOfMoney.Types (Currency(..), AmountOfMoneyData (..))\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers (isPositive)\nimport Duckling.Numeral.Types (NumeralData (..))\nimport Duckling.Regex.Types\nimport Duckling.Types\nimport qualified Duckling.AmountOfMoney.Types as TAmountOfMoney\nimport qualified Duckling.Numeral.Types as TNumeral\n\ncurrencies :: HashMap Text Currency\ncurrencies = HashMap.fromList\n [ (\"aed\", AED)\n , (\"aud\", AUD)\n , (\"bgn\", BGN)\n , (\"brl\", BRL)\n , (\"byn\", BYN)\n , (\"cad\", CAD)\n , (\"\u00c2\u00a2\", Cent)\n , (\"c\", Cent)\n , (\"chf\", CHF)\n , (\"cny\", CNY)\n , (\"czk\", CZK)\n , (\"rmb\", CNY)\n , (\"yuan\", CNY)\n , (\"$\", Dollar)\n , (\"dinar\", Dinar)\n , (\"dinars\", Dinar)\n , (\"dkk\", DKK)\n , (\"dollar\", Dollar)\n , (\"dollars\", Dollar)\n , (\"egp\", EGP)\n , (\"\u00e2\u201a\u00ac\", EUR)\n , (\"eur\", EUR)\n , (\"euro\", EUR)\n , (\"euros\", EUR)\n , (\"eurs\", EUR)\n , (\"\u00e2\u201a\u00acur\", EUR)\n , (\"\u00e2\u201a\u00acuro\", EUR)\n , (\"\u00e2\u201a\u00acuros\", EUR)\n , (\"\u00e2\u201a\u00acurs\", EUR)\n , (\"gbp\", GBP)\n , (\"gel\", GEL)\n , (\"hkd\", HKD)\n , (\"hrk\", HRK)\n , (\"idr\", IDR)\n , (\"ils\", ILS)\n , (\"\u00e2\u201a\u00aa\", ILS)\n , (\"nis\", ILS)\n , (\"inr\", INR)\n , (\"iqd\", IQD)\n , (\"rs\", INR)\n , (\"rs.\", INR)\n , (\"rupee\", INR)\n , (\"rupees\", INR)\n , (\"jmd\", JMD)\n , (\"jod\", JOD)\n , (\"\u00c2\u00a5\", JPY)\n , (\"jpy\", JPY)\n , (\"lari\", GEL)\n , (\"\\x20BE\", GEL)\n , (\"yen\", JPY)\n , (\"krw\", KRW)\n , (\"kwd\", KWD)\n , (\"lbp\", LBP)\n , (\"mad\", MAD)\n , (\"mnt\", MNT)\n , (\"myr\", MYR)\n , (\"rm\", MYR)\n , (\"\u00e2\u201a\u00ae\", MNT)\n , (\"tugrik\", MNT)\n , (\"tugriks\", MNT)\n , (\"nok\", NOK)\n , (\"nzd\", NZD)\n , (\"pkr\", PKR)\n , (\"pln\", PLN)\n , (\"\u00c2\u00a3\", Pound)\n , (\"pt\", PTS)\n , (\"pta\", PTS)\n , (\"ptas\", PTS)\n , (\"pts\", PTS)\n , (\"qar\", QAR)\n , (\"\u00e2\u201a\u00bd\", RUB)\n , (\"rial\", Rial)\n , (\"rials\", Rial)\n , (\"riyal\", Riyal)\n , (\"riyals\", Riyal)\n , (\"ron\", RON)\n , (\"rub\", RUB)\n , (\"sar\", SAR)\n , (\"sek\", SEK)\n , (\"sgd\", SGD)\n , (\"shekel\", ILS)\n , (\"shekels\", ILS)\n , (\"thb\", THB)\n , (\"ttd\", TTD)\n , (\"\u00e2\u201a\u00b4\", UAH)\n , (\"uah\", UAH)\n , (\"usd\", USD)\n , (\"us$\", USD)\n , (\"vnd\", VND)\n , (\"zar\", ZAR)\n , (\"tl\", TRY)\n , (\"lira\", TRY)\n , (\"\u00e2\u201a\u00ba\", TRY)\n ]\n\nruleCurrencies :: Rule\nruleCurrencies = Rule\n { name = \"currencies\"\n , pattern =\n [ regex \"(aed|aud|bgn|brl|byn|\u00c2\u00a2|cad|chf|cny|c|\\\\$|dinars?|dkk|dollars?|egp|(e|\u00e2\u201a\u00ac)uro?s?|\u00e2\u201a\u00ac|gbp|gel|\\x20BE|hkd|hrk|idr|ils|\u00e2\u201a\u00aa|inr|iqd|jmd|jod|\u00c2\u00a5|jpy|lari|krw|kwd|lbp|mad|\u00e2\u201a\u00ae|mnt|tugriks?|myr|rm|nis|nok|nzd|\u00c2\u00a3|pkr|pln|pta?s?|qar|\u00e2\u201a\u00bd|rs\\\\.?|riy?als?|ron|rub|rupees?|sar|sek|sgb|shekels?|thb|ttd|\u00e2\u201a\u00b4|uah|us(d|\\\\$)|vnd|yen|yuan|zar|tl|lira|\u00e2\u201a\u00ba)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> do\n c <- HashMap.lookup (Text.toLower match) currencies\n Just . Token AmountOfMoney $ currencyOnly c\n _ -> Nothing\n }\n\nruleAmountUnit :: Rule\nruleAmountUnit = Rule\n { name = \" \"\n , pattern =\n [ Predicate isPositive\n , Predicate isCurrencyOnly\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v}:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.currency = c}:\n _) -> Just . Token AmountOfMoney . withValue v $ currencyOnly c\n _ -> Nothing\n }\n\nruleAmountLatent :: Rule\nruleAmountLatent = Rule\n { name = \" (latent)\"\n , pattern =\n [ Predicate isPositive\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v}:_) ->\n Just . Token AmountOfMoney . mkLatent $ valueOnly v\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleAmountUnit\n , ruleAmountLatent\n , ruleCurrencies\n ]\n", "num_lines": 175} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE DeriveAnyClass #-}\n{-# LANGUAGE DeriveGeneric #-}\n{-# LANGUAGE NamedFieldPuns #-}\n{-# LANGUAGE NoRebindableSyntax #-}\n{-# LANGUAGE OverloadedStrings #-}\n{-# LANGUAGE TypeFamilies #-}\n\nmodule Duckling.AmountOfMoney.Types where\n\nimport Control.DeepSeq\nimport Data.Aeson\nimport Data.Hashable\nimport Data.Text (Text)\nimport GHC.Generics\nimport Prelude\nimport qualified Data.HashMap.Strict as H\n\nimport Duckling.Resolve (Resolve(..), Options(..))\n\ndata Currency\n -- ambiguous\n = Cent\n | Dinar\n | Dirham\n | Dollar\n | Pound\n | Rial\n | Riyal\n | Unnamed -- e.g. bucks\n -- unambiguous\n | AED\n | AUD\n | BGN\n | BRL\n | BYN\n | CAD\n | CHF\n | CNY\n | CZK\n | DKK\n | EGP\n | EUR\n | GBP\n | HKD\n | HRK\n | IDR\n | ILS\n | INR\n | IQD\n | JMD\n | JOD\n | JPY\n | GEL\n | KRW\n | KWD\n | LBP\n | MAD\n | MNT\n | MYR\n | NOK\n | NZD\n | PKR\n | PLN\n | PTS\n | QAR\n | RON\n | RUB\n | SAR\n | SEK\n | SGD\n | THB\n | TTD\n | USD\n | VND\n | ZAR\n | UAH\n | TRY\n deriving (Eq, Generic, Hashable, Show, Ord, NFData)\n\ninstance ToJSON Currency where\n toJSON Cent = \"cent\"\n toJSON Dollar = \"$\"\n toJSON Pound = \"\\x00a3\"\n toJSON Dinar = \"dinar\"\n toJSON Dirham = \"dirham\"\n toJSON Rial = \"rial\"\n toJSON Riyal = \"riyal\"\n toJSON Unnamed = \"unknown\"\n toJSON AED = \"AED\"\n toJSON AUD = \"AUD\"\n toJSON BGN = \"BGN\"\n toJSON BRL = \"BRL\"\n toJSON BYN = \"BYN\"\n toJSON CAD = \"CAD\"\n toJSON CHF = \"CHF\"\n toJSON CNY = \"CNY\"\n toJSON CZK = \"CZK\"\n toJSON DKK = \"DKK\"\n toJSON EGP = \"EGP\"\n toJSON EUR = \"EUR\"\n toJSON GBP = \"GBP\"\n toJSON HKD = \"HKD\"\n toJSON HRK = \"HRK\"\n toJSON IDR = \"IDR\"\n toJSON ILS = \"ILS\"\n toJSON IQD = \"IQD\"\n toJSON INR = \"INR\"\n toJSON JMD = \"JMD\"\n toJSON JOD = \"JOD\"\n toJSON JPY = \"JPY\"\n toJSON GEL = \"GEL\"\n toJSON KRW = \"KRW\"\n toJSON KWD = \"KWD\"\n toJSON LBP = \"LBP\"\n toJSON MAD = \"MAD\"\n toJSON MNT = \"MNT\"\n toJSON MYR = \"MYR\"\n toJSON NOK = \"NOK\"\n toJSON NZD = \"NZD\"\n toJSON PTS = \"PTS\"\n toJSON PKR = \"PKR\"\n toJSON PLN = \"PLN\"\n toJSON QAR = \"QAR\"\n toJSON RON = \"RON\"\n toJSON RUB = \"RUB\"\n toJSON SAR = \"SAR\"\n toJSON SEK = \"SEK\"\n toJSON SGD = \"SGD\"\n toJSON THB = \"THB\"\n toJSON TTD = \"TTD\"\n toJSON USD = \"USD\"\n toJSON VND = \"VND\"\n toJSON ZAR = \"ZAR\"\n toJSON UAH = \"UAH\"\n toJSON TRY = \"TRY\"\n\ndata AmountOfMoneyData = AmountOfMoneyData\n { value :: Maybe Double\n , currency :: Currency\n , minValue :: Maybe Double\n , maxValue :: Maybe Double\n , latent :: Bool\n }\n deriving (Eq, Generic, Hashable, Show, Ord, NFData)\n\ninstance Resolve AmountOfMoneyData where\n type ResolvedValue AmountOfMoneyData = AmountOfMoneyValue\n resolve _ Options {withLatent = False} AmountOfMoneyData {latent = True} =\n Nothing\n resolve _ _ AmountOfMoneyData {value = Nothing, minValue = Nothing\n , maxValue = Nothing} =\n Nothing\n resolve _ _ AmountOfMoneyData {value = Just value, currency, latent} =\n Just (simple currency value, latent)\n resolve _ _ AmountOfMoneyData {value = Nothing, currency = c\n , minValue = Just from, maxValue = Just to\n , latent} =\n Just (between c (from, to), latent)\n resolve _ _ AmountOfMoneyData {value = Nothing, currency = c\n , minValue = Just v, maxValue = Nothing\n , latent} =\n Just (above c v, latent)\n resolve _ _ AmountOfMoneyData {value = Nothing, currency = c\n , minValue = Nothing, maxValue = Just v\n , latent} =\n Just (under c v, latent)\n\namountOfMoneyData' :: AmountOfMoneyData\namountOfMoneyData' = AmountOfMoneyData\n { value = Nothing\n , currency = Unnamed\n , minValue = Nothing\n , maxValue = Nothing\n , latent = False\n }\n\ndata IntervalDirection = Above | Under\n deriving (Eq, Generic, Hashable, Ord, Show, NFData)\n\ndata SingleValue = SingleValue\n { vCurrency :: Currency\n , vValue :: Double\n }\n deriving (Eq, Show)\n\ninstance ToJSON SingleValue where\n toJSON SingleValue {vCurrency, vValue} = object\n [ \"value\" .= vValue\n , \"unit\" .= vCurrency\n ]\n\ndata AmountOfMoneyValue\n = SimpleValue SingleValue\n | IntervalValue (SingleValue, SingleValue)\n | OpenIntervalValue (SingleValue, IntervalDirection)\n deriving (Show, Eq)\n\ninstance ToJSON AmountOfMoneyValue where\n toJSON (SimpleValue value) = case toJSON value of\n Object o -> Object $ H.insert \"type\" (toJSON (\"value\" :: Text)) o\n _ -> Object H.empty\n toJSON (IntervalValue (from, to)) = object\n [ \"type\" .= (\"interval\" :: Text)\n , \"from\" .= toJSON from\n , \"to\" .= toJSON to\n ]\n toJSON (OpenIntervalValue (from, Above)) = object\n [ \"type\" .= (\"interval\" :: Text)\n , \"from\" .= toJSON from\n ]\n toJSON (OpenIntervalValue (to, Under)) = object\n [ \"type\" .= (\"interval\" :: Text)\n , \"to\" .= toJSON to\n ]\n\n-- -----------------------------------------------------------------\n-- Value helpers\n\nsimple :: Currency -> Double -> AmountOfMoneyValue\nsimple c v = SimpleValue $ single c v\n\nbetween :: Currency -> (Double, Double) -> AmountOfMoneyValue\nbetween c (from, to) = IntervalValue (single c from, single c to)\n\nabove :: Currency -> Double -> AmountOfMoneyValue\nabove = openInterval Above\n\nunder :: Currency -> Double -> AmountOfMoneyValue\nunder = openInterval Under\n\nopenInterval :: IntervalDirection -> Currency -> Double -> AmountOfMoneyValue\nopenInterval direction c v = OpenIntervalValue (single c v, direction)\n\nsingle :: Currency -> Double -> SingleValue\nsingle c v = SingleValue {vCurrency = c, vValue = v}\n", "num_lines": 243} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.AR.Corpus\n ( corpus\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.AmountOfMoney.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale AR Nothing},\n testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple Dollar 1)\n [ \"$1\"\n , \"1 \u00d8\u00af\u00d9\u02c6\u00d9\u201e\u00d8\u00a7\u00d8\u00b1\"\n ]\n , examples (simple Dollar 10)\n [ \"$10\"\n , \"$ 10\"\n , \"10 $\"\n , \"10$\"\n , \"10$\"\n , \"10 \u00d8\u00af\u00d9\u02c6\u00d9\u201e\u00d8\u00a7\u00d8\u00b1\"\n , \"\u00d8\u00b9\u00d8\u00b4\u00d8\u00b1\u00d8\u00a9 \u00d8\u00af\u00d9\u02c6\u00d9\u201e\u00d8\u00a7\u00d8\u00b1\u00d8\u00a7\u00d8\u00aa\"\n ]\n , examples (simple Cent 10)\n [ \"10 \u00d8\u00b3\u00d9\u2020\u00d8\u00aa\u00d8\u00a7\u00d8\u00aa\"\n , \"10 \u00d8\u00b3\u00d9\u2020\u00d8\u00aa\"\n , \"10 \u00d8\u00b3\u00d9\u0160\u00d9\u2020\u00d8\u00aa\"\n , \"10 \u00d8\u00b3\u00d9\u0160\u00d9\u2020\u00d8\u00aa\u00d8\u00a7\u00d8\u00aa\"\n , \"10 c\"\n , \"10\u00c2\u00a2\"\n ]\n , examples (simple Dollar 1e4)\n [ \"10000 \u00d8\u00af\u00d9\u02c6\u00d9\u201e\u00d8\u00a7\u00d8\u00b1\"\n , \"$10,000\"\n , \"10000$\"\n ]\n , examples (simple EUR 20)\n [ \"20 \u00d9\u0160\u00d9\u02c6\u00d8\u00b1\u00d9\u02c6\"\n , \"20 \u00d8\u00a7\u00d9\u02c6\u00d8\u00b1\u00d9\u02c6\"\n , \"20 \u00d8\u00a3\u00d9\u02c6\u00d8\u00b1\u00d9\u02c6\"\n , \"20\u00e2\u201a\u00ac\"\n , \"20 \u00e2\u201a\u00ac\"\n ]\n , examples (simple Pound 10)\n [ \"10 \u00d8\u00ac\u00d9\u2020\u00d9\u0160\u00d9\u2021\"\n , \"10 \u00d8\u00ac\u00d9\u2020\u00d9\u0160\u00d9\u2021\u00d8\u00a7\u00d8\u00aa\"\n ]\n , examples (simple Dollar 20.43)\n [ \"20$ \u00d9\u02c6 43c\"\n , \"$20 43\"\n , \"20$ 43c\"\n , \"20 \u00d8\u00af\u00d9\u02c6\u00d9\u201e\u00d8\u00a7\u00d8\u00b1 \u00d9\u02c643 \u00d8\u00b3\u00d9\u2020\u00d8\u00aa\"\n , \"20.43 $\"\n ]\n , examples (simple GBP 3)\n [ \"3 \u00d8\u00ac\u00d9\u2020\u00d9\u0160\u00d9\u2021\u00d8\u00a7\u00d8\u00aa \u00d8\u00a7\u00d8\u00b3\u00d8\u00aa\u00d8\u00b1\u00d9\u201e\u00d9\u0160\u00d9\u2020\u00d9\u0160\u00d8\u00a9\"\n , \"3 \u00d8\u00ac\u00d9\u2020\u00d9\u0160\u00d9\u2021 \u00d8\u00a7\u00d8\u00b3\u00d8\u00aa\u00d8\u00b1\u00d9\u201e\u00d9\u0160\u00d9\u2020\u00d9\u0160\"\n ]\n , examples (simple KWD 42)\n [ \"42 KWD\"\n , \"42 \u00d8\u00af\u00d9\u0160\u00d9\u2020\u00d8\u00a7\u00d8\u00b1 \u00d9\u0192\u00d9\u02c6\u00d9\u0160\u00d8\u00aa\u00d9\u0160\"\n ]\n , examples (simple LBP 42)\n [ \"42 LBP\"\n , \"42 \u00d9\u201e\u00d9\u0160\u00d8\u00b1\u00d8\u00a9 \u00d9\u201e\u00d8\u00a8\u00d9\u2020\u00d8\u00a7\u00d9\u2020\u00d9\u0160\u00d8\u00a9\"\n , \"42 \u00d9\u201e\u00d9\u0160\u00d8\u00b1\u00d8\u00a7\u00d8\u00aa \u00d9\u201e\u00d8\u00a8\u00d9\u2020\u00d8\u00a7\u00d9\u2020\u00d9\u0160\u00d8\u00a9\"\n ]\n , examples (simple EGP 42)\n [ \"42 EGP\"\n , \"42 \u00d8\u00ac\u00d9\u2020\u00d9\u0160\u00d9\u2021 \u00d9\u2026\u00d8\u00b5\u00d8\u00b1\u00d9\u0160\"\n , \"42 \u00d8\u00ac\u00d9\u2020\u00d9\u0160\u00d9\u2021\u00d8\u00a7\u00d8\u00aa \u00d9\u2026\u00d8\u00b5\u00d8\u00b1\u00d9\u0160\u00d9\u2021\"\n , \"42 \u00d8\u00ac.\u00d9\u2026\"\n , \"42 \u00d8\u00ac.\u00d9\u2026.\"\n ]\n , examples (simple QAR 42)\n [ \"42 QAR\"\n , \"42 \u00d8\u00b1\u00d9\u0160\u00d8\u00a7\u00d9\u201e \u00d9\u201a\u00d8\u00b7\u00d8\u00b1\u00d9\u0160\"\n , \"42 \u00d8\u00b1\u00d9\u0160\u00d8\u00a7\u00d9\u201e\u00d8\u00a7\u00d8\u00aa \u00d9\u201a\u00d8\u00b7\u00d8\u00b1\u00d9\u0160\u00d8\u00a9\"\n ]\n , examples (simple SAR 42)\n [ \"42 SAR\"\n , \"42 \u00d8\u00b1\u00d9\u0160\u00d8\u00a7\u00d9\u201e \u00d8\u00b3\u00d8\u00b9\u00d9\u02c6\u00d8\u00af\u00d9\u0160\"\n ]\n , examples (between Dollar (10, 20))\n [ \"\u00d9\u2026\u00d9\u2020 10 \u00d8\u00a7\u00d9\u201e\u00d9\u2030 20 \u00d8\u00af\u00d9\u02c6\u00d9\u201e\u00d8\u00a7\u00d8\u00b1\"\n , \"\u00d8\u00a8\u00d8\u00ad\u00d8\u00af\u00d9\u02c6\u00d8\u00af 10-20 \u00d8\u00af\u00d9\u02c6\u00d9\u201e\u00d8\u00a7\u00d8\u00b1\"\n , \"\u00d9\u2026\u00d8\u00a7 \u00d8\u00a8\u00d9\u0160\u00d9\u2020 \u00d8\u00b9\u00d8\u00b4\u00d8\u00b1\u00d8\u00a9 \u00d9\u02c6\u00d8\u00b9\u00d8\u00b4\u00d8\u00b1\u00d9\u02c6\u00d9\u2020 \u00d8\u00af\u00d9\u02c6\u00d9\u201e\u00d8\u00a7\u00d8\u00b1\"\n , \"\u00d9\u2026\u00d9\u2020 \u00d8\u00b9\u00d8\u00b4\u00d8\u00b1\u00d8\u00a9 \u00d9\u201e\u00d8\u00b9\u00d8\u00b4\u00d8\u00b1\u00d9\u0160\u00d9\u2020 \u00d8\u00af\u00d9\u02c6\u00d9\u201e\u00d8\u00a7\u00d8\u00b1\"\n , \"\u00d8\u00ad\u00d9\u02c6\u00d8\u00a7\u00d9\u201e\u00d9\u0160 10$-20$\"\n , \"10-20 $\"\n , \"10-20 \u00d8\u00af\u00d9\u02c6\u00d9\u201e\u00d8\u00a7\u00d8\u00b1\"\n ]\n , examples (under EUR 7)\n [ \"\u00d8\u00aa\u00d8\u00ad\u00d8\u00aa \u00d8\u00b3\u00d8\u00a8\u00d8\u00b9\u00d8\u00a9 \u00d8\u00a7\u00d9\u02c6\u00d8\u00b1\u00d9\u02c6\"\n , \"\u00d8\u00a7\u00d9\u201a\u00d9\u201e \u00d9\u2026\u00d9\u2020 \u00d8\u00b3\u00d8\u00a8\u00d8\u00b9\u00d8\u00a9 \u00d9\u0160\u00d9\u02c6\u00d8\u00b1\u00d9\u02c6\"\n , \"\u00d8\u00a7\u00d9\u201a\u00d9\u201e \u00d9\u2026\u00d9\u2020 7 \u00d9\u0160\u00d9\u02c6\u00d8\u00b1\u00d9\u02c6\"\n ]\n , examples (above Dollar 3.42)\n [ \"\u00d8\u00a7\u00d9\u0192\u00d8\u00ab\u00d8\u00b1 \u00d9\u2026\u00d9\u2020 \u00d8\u00ab\u00d9\u201e\u00d8\u00a7\u00d8\u00ab\u00d8\u00a9 \u00d8\u00af\u00d9\u02c6\u00d9\u201e\u00d8\u00a7\u00d8\u00b1 \u00d9\u02c642 \u00d8\u00b3\u00d9\u0160\u00d9\u2020\u00d8\u00aa\"\n , \"3.42$ \u00d8\u00b9\u00d9\u201e\u00d9\u2030 \u00d8\u00a7\u00d9\u201e\u00d8\u00a7\u00d9\u201a\u00d9\u201e\"\n ]\n , examples (simple JOD 5)\n [ \"5 \u00d8\u00af\u00d9\u0160\u00d9\u2020\u00d8\u00a7\u00d8\u00b1 \u00d8\u00a7\u00d8\u00b1\u00d8\u00af\u00d9\u2020\u00d9\u0160\"\n , \"5 \u00d8\u00af\u00d9\u2020\u00d8\u00a7\u00d9\u2020\u00d9\u0160\u00d8\u00b1 \u00d8\u00a3\u00d8\u00b1\u00d8\u00af\u00d9\u2020\u00d9\u0160\u00d8\u00a9\"\n ]\n , examples (simple ILS 5)\n [ \"5 \u00d8\u00b4\u00d9\u0160\u00d9\u201a\u00d9\u201e\"\n , \"5 \u00d8\u00b4\u00d9\u02c6\u00d8\u00a7\u00d9\u201a\u00d9\u201e\"\n , \"\u00d8\u00ae\u00d9\u2026\u00d8\u00b3\u00d8\u00a9 \u00d8\u00b4\u00d9\u0160\u00d9\u0192\u00d9\u201e\"\n ]\n ]\n", "num_lines": 129} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.CA.Corpus\n ( corpus\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.AmountOfMoney.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale CA Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple Dollar 10)\n [ \"$10\"\n , \"10$\"\n , \"deu dolars\"\n , \"deu d\u00c3\u00b2lars\"\n ]\n , examples (simple Dollar 10000)\n [ \"$10.000\"\n , \"10K$\"\n , \"$10k\"\n ]\n , examples (simple USD 1.23)\n [ \"USD1,23\"\n ]\n , examples (simple EUR 20)\n [ \"20\u00e2\u201a\u00ac\"\n , \"20 euros\"\n , \"20 Euro\"\n , \"20 Euros\"\n , \"EUR 20\"\n , \"vint euros\"\n ]\n , examples (simple EUR 29.99)\n [ \"EUR29,99\"\n , \"29,99 euros\"\n , \"29,99 \u00e2\u201a\u00ac\"\n , \"29,99\u00e2\u201a\u00ac\"\n ]\n , examples (simple Pound 9)\n [ \"\u00c2\u00a39\"\n , \"nou lliures\"\n , \"9 lliures\"\n ]\n ,examples (simple Pound 1)\n [ \"\u00c2\u00a31\"\n , \"una lliura\"\n , \"1 lliura\"\n ]\n , examples (simple GBP 3.01)\n [ \"GBP3,01\"\n , \"GBP 3,01\"\n , \"3 gbp 1 c\u00c3\u00a8ntims\"\n , \"3 gbp i 1 c\u00c3\u00a8ntims\"\n ]\n , examples (simple PTS 15)\n [ \"15 Pt\"\n , \"15pta\"\n , \"15Ptas\"\n ]\n , examples (between Dollar (10, 20))\n [ \"entre 10 i 20 d\u00c3\u00b2lars\"\n , \"des de $10 fins a $20\"\n , \"10$ - 20 dolars\"\n , \"10 - 20 $\"\n ]\n , examples (under Dollar 10)\n [ \"menys de 10 dolars\"\n , \"no m\u00c3\u00a9s de 10$\"\n ]\n , examples (above Dollar 10)\n [ \"no menys de 10 d\u00c3\u00b2lars\"\n , \"m\u00c3\u00a9s de 10$\"\n ]\n ]\n", "num_lines": 91} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.CA.Rules\n ( rules\n ) where\n\nimport Data.Maybe\nimport Data.String\nimport Prelude\n\nimport Duckling.AmountOfMoney.Helpers\nimport Duckling.AmountOfMoney.Types (Currency(..), AmountOfMoneyData (..))\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers (isNatural, isPositive)\nimport Duckling.Numeral.Types (NumeralData (..))\nimport Duckling.Types\nimport qualified Duckling.AmountOfMoney.Types as TAmountOfMoney\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleUnitAmount :: Rule\nruleUnitAmount = Rule\n { name = \" \"\n , pattern =\n [ Predicate isCurrencyOnly\n , Predicate isPositive\n ]\n , prod = \\case\n (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.currency = c}:\n Token Numeral NumeralData{TNumeral.value = v}:\n _) -> Just $ Token AmountOfMoney $ withValue v $ currencyOnly c\n _ -> Nothing\n }\n\nruleDollar :: Rule\nruleDollar = Rule\n { name = \"dollar\"\n , pattern =\n [ regex \"d(\u00c3\u00b2|o|\u00c3\u00b3)lar(s)?\"\n ]\n , prod = \\_ -> Just $ Token AmountOfMoney $ currencyOnly Dollar\n }\n\nruleCent :: Rule\nruleCent = Rule\n { name = \"cent\"\n , pattern =\n [ regex \"c(e|\u00c3\u00a8)ntims?\"\n ]\n , prod = \\_ -> Just $ Token AmountOfMoney $ currencyOnly Cent\n }\n\nrulePounds :: Rule\nrulePounds = Rule\n { name = \"\u00c2\u00a3\"\n , pattern =\n [ regex \"(lliure|lliura)s?\"\n ]\n , prod = \\_ -> Just $ Token AmountOfMoney $ currencyOnly Pound\n }\n\nruleIntersectAndNumeral :: Rule\nruleIntersectAndNumeral = Rule\n { name = \"intersect (and number)\"\n , pattern =\n [ Predicate isWithoutCents\n , regex \"i\"\n , Predicate isNatural\n ]\n , prod = \\case\n (Token AmountOfMoney fd:\n _:\n Token Numeral NumeralData{TNumeral.value = c}:\n _) -> Just $ Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nruleIntersectXCents :: Rule\nruleIntersectXCents = Rule\n { name = \"intersect (X cents)\"\n , pattern =\n [ Predicate isWithoutCents\n , Predicate isCents\n ]\n , prod = \\case\n (Token AmountOfMoney fd:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just c}:\n _) -> Just $ Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nruleIntersectAndXCents :: Rule\nruleIntersectAndXCents = Rule\n { name = \"intersect (and X cents)\"\n , pattern =\n [ Predicate isWithoutCents\n , regex \"i\"\n , Predicate isCents\n ]\n , prod = \\case\n (Token AmountOfMoney fd:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just c}:\n _) -> Just $ Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nruleIntersect :: Rule\nruleIntersect = Rule\n { name = \"intersect\"\n , pattern =\n [ Predicate isWithoutCents\n , Predicate isNatural\n ]\n , prod = \\case\n (Token AmountOfMoney fd:\n Token Numeral NumeralData{TNumeral.value = c}:\n _) -> Just $ Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nruleIntervalBetweenNumeral :: Rule\nruleIntervalBetweenNumeral = Rule\n { name = \"between|from to|and \"\n , pattern =\n [ regex \"des de|des d'|entre\"\n , Predicate isPositive\n , regex \"fins a|i\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\case\n (_:\n Token Numeral NumeralData{TNumeral.value = from}:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c}:\n _) | from < to ->\n Just $ Token AmountOfMoney $ withInterval (from, to) $ currencyOnly c\n _ -> Nothing\n }\n\nruleIntervalBetween :: Rule\nruleIntervalBetween = Rule\n { name = \"between|from to|and \"\n , pattern =\n [ regex \"des de|des d'|entre\"\n , Predicate isSimpleAmountOfMoney\n , regex \"fins a|i\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\case\n (_:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just from,\n TAmountOfMoney.currency = c1}:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c2}:\n _) | from < to && c1 == c2 ->\n Just $ Token AmountOfMoney $ withInterval (from, to) $ currencyOnly c1\n _ -> Nothing\n }\n\nruleIntervalNumeralDash :: Rule\nruleIntervalNumeralDash = Rule\n { name = \" - \"\n , pattern =\n [ Predicate isNatural\n , regex \"-\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = from}:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c}:\n _) | from < to->\n Just $ Token AmountOfMoney $ withInterval (from, to) $ currencyOnly c\n _ -> Nothing\n }\n\nruleIntervalDash :: Rule\nruleIntervalDash = Rule\n { name = \" - \"\n , pattern =\n [ Predicate isSimpleAmountOfMoney\n , regex \"-\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\case\n (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just from,\n TAmountOfMoney.currency = c1}:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c2}:\n _) | from < to && c1 == c2 ->\n Just $ Token AmountOfMoney $ withInterval (from, to) $ currencyOnly c1\n _ -> Nothing\n }\n\nruleIntervalMax :: Rule\nruleIntervalMax = Rule\n { name = \"less/no more than \"\n , pattern =\n [ regex \"menys de|no m(e|\u00c3\u00a9)s de|no m(e|\u00c3\u00a9)s d'|menys d'\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\case\n (_:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c}:\n _) -> Just $ Token AmountOfMoney $ withMax to $ currencyOnly c\n _ -> Nothing\n }\n\nruleIntervalMin :: Rule\nruleIntervalMin = Rule\n { name = \"no less/more than \"\n , pattern =\n [ regex \"m(e|\u00c3\u00a9)s de|no menys de|m(e|\u00c3\u00a9)s d'|no menys d'\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\case\n (_:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c}:\n _) -> Just $ Token AmountOfMoney $ withMin to $ currencyOnly c\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleUnitAmount\n , ruleCent\n , ruleDollar\n , ruleIntersect\n , ruleIntersectAndNumeral\n , ruleIntersectAndXCents\n , ruleIntersectXCents\n , rulePounds\n , ruleIntervalBetweenNumeral\n , ruleIntervalBetween\n , ruleIntervalNumeralDash\n , ruleIntervalDash\n , ruleIntervalMax\n , ruleIntervalMin\n ]\n", "num_lines": 255} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.EN.Corpus\n ( corpus\n , negativeCorpus\n , latentCorpus\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.AmountOfMoney.Types\nimport Duckling.Resolve (Options(..))\nimport Duckling.Testing.Types\n\nnegativeCorpus :: NegativeCorpus\nnegativeCorpus = (testContext, testOptions, examples)\n where\n examples =\n [ \"exactly dollars\"\n ]\n\ncorpus :: Corpus\ncorpus = (testContext, testOptions, allExamples)\n\nlatentCorpus :: Corpus\nlatentCorpus = (testContext, testOptions {withLatent = True}, xs)\n where\n xs = concat\n [ examples (simple Unnamed 5)\n [ \"five\"\n , \"5\"\n , \"about 5\"\n ]\n , examples (simple Unnamed 7.2)\n [ \"7.2\"\n , \"7.20000\"\n ]\n ]\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple Dollar 1)\n [ \"$1\"\n , \"one dollar\"\n , \"a dollar\"\n ]\n , examples (simple Dollar 10)\n [ \"$10\"\n , \"$ 10\"\n , \"10$\"\n , \"10 dollars\"\n , \"ten dollars\"\n ]\n , examples (simple Cent 10)\n [ \"10 cent\"\n , \"ten pennies\"\n , \"ten cents\"\n , \"10 c\"\n , \"10\u00c2\u00a2\"\n ]\n , examples (simple Dollar 1e4)\n [ \"$10K\"\n , \"10k$\"\n , \"$10,000\"\n ]\n , examples (simple USD 3.14)\n [ \"USD3.14\"\n , \"3.14US$\"\n , \"US$ 3.14\"\n , \"US$3 and fourteen\"\n ]\n , examples (simple EUR 20)\n [ \"20\\x20ac\"\n , \"20 euros\"\n , \"20 Euro\"\n , \"20 Euros\"\n , \"EUR 20\"\n , \"EUR 20.0\"\n , \"20\u00e2\u201a\u00ac\"\n , \"20 \u00e2\u201a\u00acur\"\n ]\n , examples (simple Pound 10)\n [ \"\\x00a3\\&10\"\n , \"ten pounds\"\n ]\n , examples (simple INR 20)\n [ \"Rs. 20\"\n , \"Rs 20\"\n , \"20 Rupees\"\n , \"20Rs\"\n , \"Rs20\"\n ]\n , examples (simple INR 20.43)\n [ \"20 Rupees 43\"\n , \"twenty rupees 43\"\n ]\n , examples (simple Dollar 20.43)\n [ \"$20 and 43c\"\n , \"$20 43\"\n , \"20 dollar 43c\"\n , \"20 dollars 43 cents\"\n , \"twenty dollar 43 cents\"\n , \"20 dollar 43\"\n , \"twenty dollar and 43\"\n ]\n , examples (simple GBP 3.01)\n [ \"GBP3.01\"\n , \"GBP 3.01\"\n , \"3 GBP 1 pence\"\n , \"3 GBP and one\"\n ]\n , examples (simple CAD 3.03)\n [ \"CAD3.03\"\n , \"CAD 3.03\"\n , \"3 CAD 3 cents\"\n ]\n , examples (simple CHF 3.04)\n [ \"CHF3.04\"\n , \"CHF 3.04\"\n , \"3 CHF 4 cents\"\n ]\n , examples (simple CNY 3)\n [ \"CNY3\"\n , \"CNY 3\"\n , \"3 CNY\"\n , \"3 yuan\"\n ]\n , examples (simple Unnamed 42)\n [ \"42 bucks\"\n , \"around 42 bucks\"\n , \"exactly 42 bucks\"\n ]\n , examples (simple KWD 42)\n [ \"42 KWD\"\n , \"42 kuwaiti Dinar\"\n ]\n , examples (simple LBP 42)\n [ \"42 LBP\"\n , \"42 Lebanese Pounds\"\n ]\n , examples (simple EGP 42)\n [ \"42 EGP\"\n , \"42 egyptianpound\"\n , \"42 LE\"\n , \"42 L.E\"\n , \"42 l.e.\"\n , \"42 le\"\n , \"42 geneh\"\n , \"42 genihat masriya\"\n ]\n , examples (simple QAR 42)\n [ \"42 QAR\"\n , \"42 qatari riyals\"\n ]\n , examples (simple SAR 42)\n [ \"42 SAR\"\n , \"42 Saudiriyal\"\n ]\n , examples (simple BGN 42)\n [ \"42 BGN\"\n ]\n , examples (simple MYR 42)\n [ \"42 MYR\"\n , \"42 RM\"\n , \"RM 42\"\n , \"MYR 42\"\n , \"42MYR\"\n , \"42RM\"\n , \"RM42\"\n , \"MYR42\"\n , \"ringgit 42\"\n , \"42 ringgit\"\n , \"42 malaysia ringgit\"\n , \"malaysia ringgit 42\"\n , \"42 malaysian ringgit\"\n , \"malaysian ringgit 42\"\n , \"42 malaysia ringgits\"\n , \"malaysia ringgits 42\"\n , \"42 malaysian ringgits\"\n , \"malaysian ringgits 42\"\n ]\n , examples (simple MYR 20.43)\n [ \"20 ringgit and 43c\"\n , \"20 ringgit and 43 sen\"\n , \"twenty ringgit 43 sens\"\n , \"20 ringgit 43\"\n , \"twenty ringgit and 43\"\n ]\n , examples (simple Dinar 10)\n [ \"10 dinars\"\n ]\n , examples (simple ILS 10)\n [ \"ten shekels\"\n , \"10 ILS\"\n ]\n , examples (simple Riyal 10)\n [ \"ten riyals\"\n , \"10 riyals\"\n ]\n , examples (simple Rial 10)\n [ \"ten rials\"\n , \"10 rials\"\n ]\n , examples (between Dollar (10, 20))\n [ \"between 10 and 20 dollars\"\n , \"from 10 dollars to 20 dollars\"\n , \"around 10-20 dollars\"\n , \"between 10 dollars and 20 dollars\"\n , \"from 10 to 20 dollars\"\n , \"about $10-$20\"\n , \"10-20 dollars\"\n ]\n , examples (between Dollar (1.1, 1.3))\n [ \"between 1.1 and 1.3 dollars\"\n , \"from 1 point 1 and one point three dollars\"\n ]\n , examples (under EUR 7)\n [ \"under seven euros\"\n , \"less than 7 EUR\"\n , \"lower than 7\u00e2\u201a\u00ac\"\n , \"no more than 7 euros\"\n , \"at most 7\u00e2\u201a\u00ac\"\n ]\n , examples (above Dollar 1.42)\n [ \"more than 1 dollar and forty-two cents\"\n , \"at least $1.42\"\n , \"over 1.42 dollars\"\n , \"above a dollar and 42 cents\"\n , \"no less than $1.42\"\n ]\n , examples (simple INR 5e5)\n [ \"5 lakh rupees\"\n , \"five lakhs rupees\"\n ]\n , examples (between INR (7, 9e5))\n [ \"7-9 lakh rupees\"\n ]\n , examples (simple INR 4e7)\n [ \"four crore rupees\"\n , \"4 crores rupees\"\n ]\n , examples (simple MNT 10)\n [ \"ten tugriks\"\n , \"10 Tugrik\"\n , \"10MNT\"\n ]\n , examples (simple USD 4.7e9)\n [ \"US$4.7 billion\"\n , \"a US$4.7 billion\"\n , \"a US$ 4.7 billion\"\n ]\n , examples (simple UAH 3.04)\n [ \"UAH3.04\"\n , \"UAH 3.04\"\n , \"3 UAH 4 kopiykas\"\n ]\n ]\n", "num_lines": 266} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.EN.Rules\n ( rules\n ) where\n\nimport Data.Maybe\nimport Data.String\nimport Prelude\nimport qualified Data.Text as Text\n\nimport Duckling.AmountOfMoney.Helpers\nimport Duckling.AmountOfMoney.Types (Currency(..), AmountOfMoneyData (..))\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers (isNatural, isPositive)\nimport Duckling.Numeral.Types (NumeralData (..))\nimport Duckling.Regex.Types\nimport Duckling.Types\nimport qualified Duckling.AmountOfMoney.Types as TAmountOfMoney\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleUnitAmount :: Rule\nruleUnitAmount = Rule\n { name = \" \"\n , pattern =\n [ Predicate isCurrencyOnly\n , Predicate isPositive\n ]\n , prod = \\case\n (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.currency = c}:\n Token Numeral NumeralData{TNumeral.value = v}:\n _) -> Just . Token AmountOfMoney . withValue v $ currencyOnly c\n _ -> Nothing\n }\n\nrulePounds :: Rule\nrulePounds = Rule\n { name = \"\u00c2\u00a3\"\n , pattern =\n [ regex \"pounds?\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly Pound\n }\n\nruleOtherPounds :: Rule\nruleOtherPounds = Rule\n { name = \"other pounds\"\n , pattern =\n [ regex \"(egyptian|lebanese) ?pounds?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of\n \"egyptian\" -> Just . Token AmountOfMoney $ currencyOnly EGP\n \"lebanese\" -> Just . Token AmountOfMoney $ currencyOnly LBP\n _ -> Nothing\n _ -> Nothing\n }\n\nruleEgpAbrreviation :: Rule\nruleEgpAbrreviation = Rule\n { name = \"livre \u00c3\u00a9gyptienne\"\n , pattern =\n [ regex \"[lL].?[eE].?\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly EGP\n }\n\nruleEgpArabizi :: Rule\nruleEgpArabizi = Rule\n { name = \"geneh\"\n , pattern =\n [ regex \"[Gg][eiy]*n[eiy]*h(at)?( m[aiey]?sr[eiy]+a?)?\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly EGP\n }\n\nruleRiyals :: Rule\nruleRiyals = Rule\n { name = \"riyals\"\n , pattern =\n [ regex \"(qatari|saudi) ?riyals?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of\n \"qatari\" -> Just . Token AmountOfMoney $ currencyOnly QAR\n \"saudi\" -> Just . Token AmountOfMoney $ currencyOnly SAR\n _ -> Nothing\n _ -> Nothing\n }\n\nruleDinars :: Rule\nruleDinars = Rule\n { name = \"dinars\"\n , pattern =\n [ regex \"(kuwaiti) ?dinars?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of\n \"kuwaiti\" -> Just . Token AmountOfMoney $ currencyOnly KWD\n _ -> Nothing\n _ -> Nothing\n }\n\nruleDirham :: Rule\nruleDirham = Rule\n { name = \"dirham\"\n , pattern =\n [ regex \"dirhams?\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly AED\n }\n\nruleRinggit :: Rule\nruleRinggit = Rule\n { name = \"ringgit\"\n , pattern =\n [ regex \"(malaysian? )?ringgits?\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly MYR\n }\n\nruleHryvnia :: Rule\nruleHryvnia = Rule\n { name = \"hryvnia\"\n , pattern =\n [ regex \"hryvnia\" -- TODO: complete\n ]\n , prod = \\_ -> Just $ Token AmountOfMoney $ currencyOnly UAH\n }\n\nruleCent :: Rule\nruleCent = Rule\n { name = \"cent\"\n , pattern =\n [ regex \"cents?|penn(y|ies)|pence|sens?\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly Cent\n }\n\nruleKopiyka :: Rule\nruleKopiyka = Rule\n { name = \"kopiyka\"\n , pattern =\n [ regex \"kopiy(ok|kas?)\"\n ]\n , prod = \\_ -> Just $ Token AmountOfMoney $ currencyOnly Cent\n }\n\nruleBucks :: Rule\nruleBucks = Rule\n { name = \"bucks\"\n , pattern =\n [ regex \"bucks?\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly Unnamed\n }\n\nruleACurrency :: Rule\nruleACurrency = Rule\n { name = \"a \"\n , pattern =\n [ regex \"an?\"\n , Predicate isCurrencyOnly\n ]\n , prod = \\tokens -> case tokens of\n (_:\n Token AmountOfMoney fd:\n _) -> Just . Token AmountOfMoney $ fd {TAmountOfMoney.value = Just 1}\n _ -> Nothing\n }\n\nruleAbsorbA :: Rule\nruleAbsorbA = Rule\n { name = \"a \"\n , pattern =\n [ regex \"an?\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\case\n (_:Token AmountOfMoney fd:_) -> Just $ Token AmountOfMoney fd\n _ -> Nothing\n }\n\nruleADollarCoin :: Rule\nruleADollarCoin = Rule\n { name = \"a \"\n , pattern =\n [ regex \"an?\"\n , Predicate isDollarCoin\n ]\n , prod = \\tokens -> case tokens of\n (_:\n Token AmountOfMoney fd:\n _) -> Just . Token AmountOfMoney $ fd\n _ -> Nothing\n }\n\nruleNumDollarCoins :: Rule\nruleNumDollarCoins = Rule\n { name = \"X \"\n , pattern =\n [ Predicate isNatural\n , Predicate isDollarCoin\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = c}:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just d,\n TAmountOfMoney.currency = cur}:\n _) -> Just . Token AmountOfMoney $ withValue (c * d) $ currencyOnly cur\n _ -> Nothing\n }\n\nruleIntersectAndXCents :: Rule\nruleIntersectAndXCents = Rule\n { name = \"intersect (and X cents)\"\n , pattern =\n [ Predicate isWithoutCents\n , regex \"and\"\n , Predicate isCents\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just c}:\n _) -> Just . Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nruleIntersect :: Rule\nruleIntersect = Rule\n { name = \"intersect\"\n , pattern =\n [ Predicate isWithoutCents\n , Predicate isNatural\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n Token Numeral NumeralData{TNumeral.value = c}:\n _) -> Just . Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nruleIntersectAndNumeral :: Rule\nruleIntersectAndNumeral = Rule\n { name = \"intersect (and number)\"\n , pattern =\n [ Predicate isWithoutCents\n , regex \"and\"\n , Predicate isNatural\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n _:\n Token Numeral NumeralData{TNumeral.value = c}:\n _) -> Just . Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nruleIntersectXCents :: Rule\nruleIntersectXCents = Rule\n { name = \"intersect (X cents)\"\n , pattern =\n [ Predicate isWithoutCents\n , Predicate isCents\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just c}:\n _) -> Just . Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nrulePrecision :: Rule\nrulePrecision = Rule\n { name = \"about|exactly \"\n , pattern =\n [ regex \"exactly|precisely|about|approx(\\\\.|imately)?|close to|near( to)?|around|almost\"\n , Predicate isMoneyWithValue\n ]\n , prod = \\tokens -> case tokens of\n (_:token:_) -> Just token\n _ -> Nothing\n }\n\nruleIntervalBetweenNumeral :: Rule\nruleIntervalBetweenNumeral = Rule\n { name = \"between|from to|and \"\n , pattern =\n [ regex \"between|from\"\n , Predicate isPositive\n , regex \"to|and\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\tokens -> case tokens of\n (_:\n Token Numeral NumeralData{TNumeral.value = from}:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c}:\n _) | from < to ->\n Just . Token AmountOfMoney . withInterval (from, to) $ currencyOnly c\n _ -> Nothing\n }\n\nruleIntervalBetween :: Rule\nruleIntervalBetween = Rule\n { name = \"between|from to|and \"\n , pattern =\n [ regex \"between|from\"\n , Predicate isSimpleAmountOfMoney\n , regex \"to|and\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\tokens -> case tokens of\n (_:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just from,\n TAmountOfMoney.currency = c1}:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c2}:\n _) | from < to && c1 == c2 ->\n Just . Token AmountOfMoney . withInterval (from, to) $ currencyOnly c1\n _ -> Nothing\n }\n\nruleIntervalNumeralDash :: Rule\nruleIntervalNumeralDash = Rule\n { name = \" - \"\n , pattern =\n [ Predicate isNatural\n , regex \"-\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = from}:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c}:\n _) | from < to->\n Just . Token AmountOfMoney . withInterval (from, to) $ currencyOnly c\n _ -> Nothing\n }\n\nruleIntervalDash :: Rule\nruleIntervalDash = Rule\n { name = \" - \"\n , pattern =\n [ Predicate isSimpleAmountOfMoney\n , regex \"-\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just from,\n TAmountOfMoney.currency = c1}:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c2}:\n _) | from < to && c1 == c2 ->\n Just . Token AmountOfMoney . withInterval (from, to) $ currencyOnly c1\n _ -> Nothing\n }\n\nruleIntervalMax :: Rule\nruleIntervalMax = Rule\n { name = \"under/less/lower/no more than \"\n , pattern =\n [ regex \"under|at most|(less|lower|not? more) than\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\tokens -> case tokens of\n (_:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c}:\n _) -> Just . Token AmountOfMoney . withMax to $ currencyOnly c\n _ -> Nothing\n }\n\nruleIntervalMin :: Rule\nruleIntervalMin = Rule\n { name = \"over/above/at least/more than \"\n , pattern =\n [ regex \"over|above|at least|(more|not? less) than\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\tokens -> case tokens of\n (_:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c}:\n _) -> Just . Token AmountOfMoney . withMin to $ currencyOnly c\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleUnitAmount\n , ruleACurrency\n , ruleAbsorbA\n , ruleBucks\n , ruleCent\n , ruleADollarCoin\n , ruleNumDollarCoins\n , ruleDinars\n , ruleDirham\n , ruleHryvnia\n , ruleIntersect\n , ruleIntersectAndNumeral\n , ruleIntersectAndXCents\n , ruleIntersectXCents\n , ruleIntervalBetweenNumeral\n , ruleIntervalBetween\n , ruleIntervalMax\n , ruleIntervalMin\n , ruleIntervalNumeralDash\n , ruleIntervalDash\n , ruleKopiyka\n , ruleOtherPounds\n , ruleEgpAbrreviation\n , ruleEgpArabizi\n , rulePounds\n , rulePrecision\n , ruleRinggit\n , ruleRiyals\n ]\n", "num_lines": 433} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.EN.AU.Corpus\n ( allExamples\n , negativeExamples\n ) where\n\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\n\nimport Duckling.AmountOfMoney.Types\nimport Duckling.Testing.Types\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple AUD 1000)\n [ \"a grand\"\n , \"1 grand\"\n ]\n , examples (simple AUD 10000)\n [ \"10 grand\"\n , \"two hundred thousand nickels\"\n ]\n , examples (simple AUD 1)\n [ \"four quarters\"\n , \"ten dimes\"\n , \"twenty nickels\"\n ]\n , examples (simple AUD 0.1)\n [ \"dime\"\n , \"a dime\"\n , \"two nickels\"\n ]\n , examples (simple AUD 0.25)\n [ \"quarter\"\n , \"a quarter\"\n , \"five nickels\"\n ]\n , examples (simple AUD 0.05)\n [ \"nickel\"\n , \"a nickel\"\n ]\n ]\n\nnegativeExamples :: [Text]\nnegativeExamples =\n [ \"grand\"\n ]\n", "num_lines": 56} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.EN.AU.Rules\n ( rules\n ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\n\nimport Duckling.AmountOfMoney.Helpers\nimport Duckling.AmountOfMoney.Types (Currency(..))\nimport Duckling.Numeral.Helpers (isPositive)\nimport Duckling.Regex.Types\nimport Duckling.Types\n\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\nimport qualified Duckling.AmountOfMoney.Helpers as Helpers\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleAGrand :: Rule\nruleAGrand = Rule\n { name = \"a grand\"\n , pattern =\n [ regex \"a grand\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney . withValue 1000 $ currencyOnly AUD\n }\n\nruleGrand :: Rule\nruleGrand = Rule\n { name = \" grand\"\n , pattern =\n [ Predicate isPositive\n , regex \"grand\"\n ]\n , prod = \\case\n (Token Numeral TNumeral.NumeralData{TNumeral.value = v}:_)\n -> Just . Token AmountOfMoney . withValue (1000 * v) $ currencyOnly AUD\n _ -> Nothing\n }\n\nruleDollarCoin :: Rule\nruleDollarCoin = Rule\n { name = \"dollar coin\"\n , pattern =\n [ regex \"(nickel|dime|quarter)s?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> do\n c <- HashMap.lookup (Text.toLower match) Helpers.dollarCoins\n Just . Token AmountOfMoney . withValue c $ currencyOnly AUD\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleAGrand\n , ruleGrand\n , ruleDollarCoin\n ]\n", "num_lines": 72} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.EN.BZ.Corpus\n ( allExamples\n , negativeExamples\n ) where\n\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\n\nimport Duckling.AmountOfMoney.Types\nimport Duckling.Testing.Types\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple Dollar 1000)\n [ \"a grand\"\n , \"1 grand\"\n ]\n , examples (simple Dollar 10000)\n [ \"10 grand\"\n , \"two hundred thousand nickels\"\n ]\n , examples (simple Dollar 1)\n [ \"four quarters\"\n , \"ten dimes\"\n , \"twenty nickels\"\n ]\n , examples (simple Dollar 0.1)\n [ \"dime\"\n , \"a dime\"\n , \"two nickels\"\n ]\n , examples (simple Dollar 0.25)\n [ \"quarter\"\n , \"a quarter\"\n , \"five nickels\"\n ]\n , examples (simple Dollar 0.05)\n [ \"nickel\"\n , \"a nickel\"\n ]\n ]\n\nnegativeExamples :: [Text]\nnegativeExamples =\n [ \"grand\"\n ]\n", "num_lines": 56} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.EN.BZ.Rules\n ( rules\n ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\n\nimport Duckling.AmountOfMoney.Helpers\nimport Duckling.AmountOfMoney.Types (Currency(..))\nimport Duckling.Numeral.Helpers (isPositive)\nimport Duckling.Regex.Types\nimport Duckling.Types\n\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\nimport qualified Duckling.AmountOfMoney.Helpers as Helpers\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleAGrand :: Rule\nruleAGrand = Rule\n { name = \"a grand\"\n , pattern =\n [ regex \"a grand\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney . withValue 1000\n $ currencyOnly Dollar\n }\n\nruleGrand :: Rule\nruleGrand = Rule\n { name = \" grand\"\n , pattern =\n [ Predicate isPositive\n , regex \"grand\"\n ]\n , prod = \\case\n (Token Numeral TNumeral.NumeralData{TNumeral.value = v}:_)\n -> Just . Token AmountOfMoney . withValue (1000 * v)\n $ currencyOnly Dollar\n _ -> Nothing\n }\n\nruleDollarCoin :: Rule\nruleDollarCoin = Rule\n { name = \"dollar coin\"\n , pattern =\n [ regex \"(nickel|dime|quarter)s?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> do\n c <- HashMap.lookup (Text.toLower match) Helpers.dollarCoins\n Just . Token AmountOfMoney . withValue c $ currencyOnly Dollar\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleAGrand\n , ruleGrand\n , ruleDollarCoin\n ]\n", "num_lines": 74} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.EN.CA.Corpus\n ( allExamples\n , negativeExamples\n ) where\n\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\n\nimport Duckling.AmountOfMoney.Types\nimport Duckling.Testing.Types\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple CAD 1000)\n [ \"a grand\"\n , \"1 grand\"\n ]\n , examples (simple CAD 10000)\n [ \"10 grand\"\n , \"two hundred thousand nickels\"\n ]\n , examples (simple CAD 1)\n [ \"four quarters\"\n , \"ten dimes\"\n , \"twenty nickels\"\n ]\n , examples (simple CAD 0.1)\n [ \"dime\"\n , \"a dime\"\n , \"two nickels\"\n ]\n , examples (simple CAD 0.25)\n [ \"quarter\"\n , \"a quarter\"\n , \"five nickels\"\n ]\n , examples (simple CAD 0.05)\n [ \"nickel\"\n , \"a nickel\"\n ]\n ]\n\nnegativeExamples :: [Text]\nnegativeExamples =\n [ \"grand\"\n ]\n", "num_lines": 56} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.EN.CA.Rules\n ( rules\n ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\n\nimport Duckling.AmountOfMoney.Helpers\nimport Duckling.AmountOfMoney.Types (Currency(..))\nimport Duckling.Numeral.Helpers (isPositive)\nimport Duckling.Regex.Types\nimport Duckling.Types\n\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\nimport qualified Duckling.AmountOfMoney.Helpers as Helpers\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleAGrand :: Rule\nruleAGrand = Rule\n { name = \"a grand\"\n , pattern =\n [ regex \"a grand\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney . withValue 1000 $ currencyOnly CAD\n }\n\nruleGrand :: Rule\nruleGrand = Rule\n { name = \" grand\"\n , pattern =\n [ Predicate isPositive\n , regex \"grand\"\n ]\n , prod = \\case\n (Token Numeral TNumeral.NumeralData{TNumeral.value = v}:_)\n -> Just . Token AmountOfMoney . withValue (1000 * v) $ currencyOnly CAD\n _ -> Nothing\n }\n\nruleDollarCoin :: Rule\nruleDollarCoin = Rule\n { name = \"dollar coin\"\n , pattern =\n [ regex \"(nickel|dime|quarter)s?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> do\n c <- HashMap.lookup (Text.toLower match) Helpers.dollarCoins\n Just . Token AmountOfMoney . withValue c $ currencyOnly CAD\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleAGrand\n , ruleGrand\n , ruleDollarCoin\n ]\n", "num_lines": 72} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.EN.GB.Corpus\n ( allExamples\n , negativeExamples\n ) where\n\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\n\nimport Duckling.AmountOfMoney.Types\nimport Duckling.Testing.Types\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple GBP 1000)\n [ \"a grand\"\n , \"1 grand\"\n ]\n , examples (simple GBP 10000)\n [ \"10 grand\"\n ]\n , examples (simple Dollar 1)\n [ \"four quarters\"\n , \"ten dimes\"\n , \"twenty nickels\"\n ]\n , examples (simple Dollar 0.1)\n [ \"dime\"\n , \"a dime\"\n , \"two nickels\"\n ]\n , examples (simple Dollar 0.25)\n [ \"quarter\"\n , \"a quarter\"\n , \"five nickels\"\n ]\n , examples (simple Dollar 0.05)\n [ \"nickel\"\n , \"a nickel\"\n ]\n ]\n\nnegativeExamples :: [Text]\nnegativeExamples =\n [ \"grand\"\n ]\n", "num_lines": 55} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.EN.GB.Rules\n ( rules\n ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\n\nimport Duckling.AmountOfMoney.Helpers\nimport Duckling.AmountOfMoney.Types (Currency(..))\nimport Duckling.Numeral.Helpers (isPositive)\nimport Duckling.Regex.Types\nimport Duckling.Types\n\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\nimport qualified Duckling.AmountOfMoney.Helpers as Helpers\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleAGrand :: Rule\nruleAGrand = Rule\n { name = \"a grand\"\n , pattern =\n [ regex \"a grand\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney . withValue 1000 $ currencyOnly GBP\n }\n\nruleGrand :: Rule\nruleGrand = Rule\n { name = \" grand\"\n , pattern =\n [ Predicate isPositive\n , regex \"grand\"\n ]\n , prod = \\case\n (Token Numeral TNumeral.NumeralData{TNumeral.value = v}:_)\n -> Just . Token AmountOfMoney . withValue (1000 * v) $ currencyOnly GBP\n _ -> Nothing\n }\n\nruleDollarCoin :: Rule\nruleDollarCoin = Rule\n { name = \"dollar coin\"\n , pattern =\n [ regex \"(nickel|dime|quarter)s?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> do\n c <- HashMap.lookup (Text.toLower match) Helpers.dollarCoins\n Just . Token AmountOfMoney . withValue c $ currencyOnly Dollar\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleAGrand\n , ruleGrand\n , ruleDollarCoin\n ]\n", "num_lines": 72} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.EN.IE.Corpus\n ( allExamples\n , negativeExamples\n ) where\n\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\n\nimport Duckling.AmountOfMoney.Types\nimport Duckling.Testing.Types\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple Dollar 1000)\n [ \"a grand\"\n , \"1 grand\"\n ]\n , examples (simple Dollar 10000)\n [ \"10 grand\"\n , \"two hundred thousand nickels\"\n ]\n , examples (simple Dollar 1)\n [ \"four quarters\"\n , \"ten dimes\"\n , \"twenty nickels\"\n ]\n , examples (simple Dollar 0.1)\n [ \"dime\"\n , \"a dime\"\n , \"two nickels\"\n ]\n , examples (simple Dollar 0.25)\n [ \"quarter\"\n , \"a quarter\"\n , \"five nickels\"\n ]\n , examples (simple Dollar 0.05)\n [ \"nickel\"\n , \"a nickel\"\n ]\n ]\n\nnegativeExamples :: [Text]\nnegativeExamples =\n [ \"grand\"\n ]\n", "num_lines": 56} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.EN.IE.Rules\n ( rules\n ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\n\nimport Duckling.AmountOfMoney.Helpers\nimport Duckling.AmountOfMoney.Types (Currency(..))\nimport Duckling.Numeral.Helpers (isPositive)\nimport Duckling.Regex.Types\nimport Duckling.Types\n\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\nimport qualified Duckling.AmountOfMoney.Helpers as Helpers\nimport qualified Duckling.Numeral.Types as TNumeral\n\n\nruleAGrand :: Rule\nruleAGrand = Rule\n { name = \"a grand\"\n , pattern =\n [ regex \"a grand\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney . withValue 1000\n $ currencyOnly Dollar\n }\n\nruleGrand :: Rule\nruleGrand = Rule\n { name = \" grand\"\n , pattern =\n [ Predicate isPositive\n , regex \"grand\"\n ]\n , prod = \\case\n (Token Numeral TNumeral.NumeralData{TNumeral.value = v}:_)\n -> Just . Token AmountOfMoney . withValue (1000 * v)\n $ currencyOnly Dollar\n _ -> Nothing\n }\n\nruleDollarCoin :: Rule\nruleDollarCoin = Rule\n { name = \"dollar coin\"\n , pattern =\n [ regex \"(nickel|dime|quarter)s?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> do\n c <- HashMap.lookup (Text.toLower match) Helpers.dollarCoins\n Just . Token AmountOfMoney . withValue c $ currencyOnly Dollar\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleAGrand\n , ruleGrand\n , ruleDollarCoin\n ]\n", "num_lines": 75} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.EN.IN.Corpus\n ( allExamples\n , negativeExamples\n ) where\n\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\n\nimport Duckling.AmountOfMoney.Types\nimport Duckling.Testing.Types\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple Dollar 1000)\n [ \"a grand\"\n , \"1 grand\"\n ]\n , examples (simple Dollar 10000)\n [ \"10 grand\"\n , \"two hundred thousand nickels\"\n ]\n , examples (simple Dollar 1)\n [ \"four quarters\"\n , \"ten dimes\"\n , \"twenty nickels\"\n ]\n , examples (simple Dollar 0.1)\n [ \"dime\"\n , \"a dime\"\n , \"two nickels\"\n ]\n , examples (simple Dollar 0.25)\n [ \"quarter\"\n , \"a quarter\"\n , \"five nickels\"\n ]\n , examples (simple Dollar 0.05)\n [ \"nickel\"\n , \"a nickel\"\n ]\n ]\n\nnegativeExamples :: [Text]\nnegativeExamples =\n [ \"grand\"\n ]\n", "num_lines": 56} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.EN.IN.Rules\n ( rules\n ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\n\nimport Duckling.AmountOfMoney.Helpers\nimport Duckling.AmountOfMoney.Types (Currency(..))\nimport Duckling.Numeral.Helpers (isPositive)\nimport Duckling.Regex.Types\nimport Duckling.Types\n\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\nimport qualified Duckling.AmountOfMoney.Helpers as Helpers\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleAGrand :: Rule\nruleAGrand = Rule\n { name = \"a grand\"\n , pattern =\n [ regex \"a grand\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney . withValue 1000 $ currencyOnly Dollar\n }\n\nruleGrand :: Rule\nruleGrand = Rule\n { name = \" grand\"\n , pattern =\n [ Predicate isPositive\n , regex \"grand\"\n ]\n , prod = \\case\n (Token Numeral TNumeral.NumeralData{TNumeral.value = v}:_)\n -> Just . Token AmountOfMoney . withValue (1000 * v) $ currencyOnly Dollar\n _ -> Nothing\n }\n\nruleDollarCoin :: Rule\nruleDollarCoin = Rule\n { name = \"dollar coin\"\n , pattern =\n [ regex \"(nickel|dime|quarter)s?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> do\n c <- HashMap.lookup (Text.toLower match) Helpers.dollarCoins\n Just . Token AmountOfMoney . withValue c $ currencyOnly Dollar\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleAGrand\n , ruleGrand\n , ruleDollarCoin\n ]\n", "num_lines": 72} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.EN.JM.Corpus\n ( allExamples\n , negativeExamples\n ) where\n\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\n\nimport Duckling.AmountOfMoney.Types\nimport Duckling.Testing.Types\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple JMD 1000)\n [ \"a grand\"\n , \"1 grand\"\n ]\n , examples (simple JMD 10000)\n [ \"10 grand\"\n , \"two hundred thousand nickels\"\n ]\n , examples (simple JMD 1)\n [ \"four quarters\"\n , \"ten dimes\"\n , \"twenty nickels\"\n ]\n , examples (simple JMD 0.1)\n [ \"dime\"\n , \"a dime\"\n , \"two nickels\"\n ]\n , examples (simple JMD 0.25)\n [ \"quarter\"\n , \"a quarter\"\n , \"five nickels\"\n ]\n , examples (simple JMD 0.05)\n [ \"nickel\"\n , \"a nickel\"\n ]\n ]\nnegativeExamples :: [Text]\nnegativeExamples =\n [ \"grand\"\n ]\n", "num_lines": 55} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.EN.JM.Rules\n ( rules\n ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\n\nimport Duckling.AmountOfMoney.Helpers\nimport Duckling.AmountOfMoney.Types (Currency(..))\nimport Duckling.Numeral.Helpers (isPositive)\nimport Duckling.Regex.Types\nimport Duckling.Types\n\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\nimport qualified Duckling.AmountOfMoney.Helpers as Helpers\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleAGrand :: Rule\nruleAGrand = Rule\n { name = \"a grand\"\n , pattern =\n [ regex \"a grand\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney . withValue 1000\n $ currencyOnly JMD\n }\n\nruleGrand :: Rule\nruleGrand = Rule\n { name = \" grand\"\n , pattern =\n [ Predicate isPositive\n , regex \"grand\"\n ]\n , prod = \\case\n (Token Numeral TNumeral.NumeralData{TNumeral.value = v}:_)\n -> Just . Token AmountOfMoney . withValue (1000 * v)\n $ currencyOnly JMD\n _ -> Nothing\n }\n\nruleDollarCoin :: Rule\nruleDollarCoin = Rule\n { name = \"dollar coin\"\n , pattern =\n [ regex \"(nickel|dime|quarter)s?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> do\n c <- HashMap.lookup (Text.toLower match) Helpers.dollarCoins\n Just . Token AmountOfMoney . withValue c $ currencyOnly JMD\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleAGrand\n , ruleGrand\n , ruleDollarCoin\n ]\n", "num_lines": 74} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.EN.NZ.Corpus\n ( allExamples\n , negativeExamples\n ) where\n\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\n\nimport Duckling.AmountOfMoney.Types\nimport Duckling.Testing.Types\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple NZD 1000)\n [ \"a grand\"\n , \"1 grand\"\n ]\n , examples (simple NZD 10000)\n [ \"10 grand\"\n , \"two hundred thousand nickels\"\n ]\n , examples (simple NZD 1)\n [ \"four quarters\"\n , \"ten dimes\"\n , \"twenty nickels\"\n ]\n , examples (simple NZD 0.1)\n [ \"dime\"\n , \"a dime\"\n , \"two nickels\"\n ]\n , examples (simple NZD 0.25)\n [ \"quarter\"\n , \"a quarter\"\n , \"five nickels\"\n ]\n , examples (simple NZD 0.05)\n [ \"nickel\"\n , \"a nickel\"\n ]\n ]\n\nnegativeExamples :: [Text]\nnegativeExamples =\n [ \"grand\"\n ]\n", "num_lines": 56} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.EN.NZ.Rules\n ( rules\n ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\n\nimport Duckling.AmountOfMoney.Helpers\nimport Duckling.AmountOfMoney.Types (Currency(..))\nimport Duckling.Numeral.Helpers (isPositive)\nimport Duckling.Regex.Types\nimport Duckling.Types\n\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\nimport qualified Duckling.AmountOfMoney.Helpers as Helpers\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleAGrand :: Rule\nruleAGrand = Rule\n { name = \"a grand\"\n , pattern =\n [ regex \"a grand\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney . withValue 1000\n $ currencyOnly NZD\n }\n\nruleGrand :: Rule\nruleGrand = Rule\n { name = \" grand\"\n , pattern =\n [ Predicate isPositive\n , regex \"grand\"\n ]\n , prod = \\case\n (Token Numeral TNumeral.NumeralData{TNumeral.value = v}:_)\n -> Just . Token AmountOfMoney . withValue (1000 * v)\n $ currencyOnly NZD\n _ -> Nothing\n }\n\nruleDollarCoin :: Rule\nruleDollarCoin = Rule\n { name = \"dollar coin\"\n , pattern =\n [ regex \"(nickel|dime|quarter)s?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> do\n c <- HashMap.lookup (Text.toLower match) Helpers.dollarCoins\n Just . Token AmountOfMoney . withValue c $ currencyOnly NZD\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleAGrand\n , ruleGrand\n , ruleDollarCoin\n ]\n", "num_lines": 74} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.EN.PH.Corpus\n ( allExamples\n , negativeExamples\n ) where\n\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\n\nimport Duckling.AmountOfMoney.Types\nimport Duckling.Testing.Types\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple Dollar 1000)\n [ \"a grand\"\n , \"1 grand\"\n ]\n , examples (simple Dollar 10000)\n [ \"10 grand\"\n , \"two hundred thousand nickels\"\n ]\n , examples (simple Dollar 1)\n [ \"four quarters\"\n , \"ten dimes\"\n , \"twenty nickels\"\n ]\n , examples (simple Dollar 0.1)\n [ \"dime\"\n , \"a dime\"\n , \"two nickels\"\n ]\n , examples (simple Dollar 0.25)\n [ \"quarter\"\n , \"a quarter\"\n , \"five nickels\"\n ]\n , examples (simple Dollar 0.05)\n [ \"nickel\"\n , \"a nickel\"\n ]\n ]\n\nnegativeExamples :: [Text]\nnegativeExamples =\n [ \"grand\"\n ]\n", "num_lines": 56} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.EN.PH.Rules\n ( rules\n ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\n\nimport Duckling.AmountOfMoney.Helpers\nimport Duckling.AmountOfMoney.Types (Currency(..))\nimport Duckling.Numeral.Helpers (isPositive)\nimport Duckling.Regex.Types\nimport Duckling.Types\n\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\nimport qualified Duckling.AmountOfMoney.Helpers as Helpers\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleAGrand :: Rule\nruleAGrand = Rule\n { name = \"a grand\"\n , pattern =\n [ regex \"a grand\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney . withValue 1000\n $ currencyOnly Dollar\n }\n\nruleGrand :: Rule\nruleGrand = Rule\n { name = \" grand\"\n , pattern =\n [ Predicate isPositive\n , regex \"grand\"\n ]\n , prod = \\case\n (Token Numeral TNumeral.NumeralData{TNumeral.value = v}:_)\n -> Just . Token AmountOfMoney . withValue (1000 * v)\n $ currencyOnly Dollar\n _ -> Nothing\n }\n\nruleDollarCoin :: Rule\nruleDollarCoin = Rule\n { name = \"dollar coin\"\n , pattern =\n [ regex \"(nickel|dime|quarter)s?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> do\n c <- HashMap.lookup (Text.toLower match) dollarCoins\n Just . Token AmountOfMoney . withValue c $ Helpers.currencyOnly Dollar\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleAGrand\n , ruleGrand\n , ruleDollarCoin\n ]\n", "num_lines": 74} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.EN.TT.Corpus\n ( allExamples\n , negativeExamples\n ) where\n\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\n\nimport Duckling.AmountOfMoney.Types\nimport Duckling.Testing.Types\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple TTD 1000)\n [ \"a grand\"\n , \"1 grand\"\n ]\n , examples (simple TTD 10000)\n [ \"10 grand\"\n , \"two hundred thousand nickels\"\n ]\n , examples (simple TTD 1)\n [ \"four quarters\"\n , \"ten dimes\"\n , \"twenty nickels\"\n ]\n , examples (simple TTD 0.1)\n [ \"dime\"\n , \"a dime\"\n , \"two nickels\"\n ]\n , examples (simple TTD 0.25)\n [ \"quarter\"\n , \"a quarter\"\n , \"five nickels\"\n ]\n , examples (simple TTD 0.05)\n [ \"nickel\"\n , \"a nickel\"\n ]\n ]\n\nnegativeExamples :: [Text]\nnegativeExamples =\n [ \"grand\"\n ]\n", "num_lines": 56} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.EN.TT.Rules\n ( rules\n ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\n\nimport Duckling.AmountOfMoney.Helpers\nimport Duckling.AmountOfMoney.Types (Currency(..))\nimport Duckling.Numeral.Helpers (isPositive)\nimport Duckling.Regex.Types\nimport Duckling.Types\n\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\nimport qualified Duckling.AmountOfMoney.Helpers as Helpers\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleAGrand :: Rule\nruleAGrand = Rule\n { name = \"a grand\"\n , pattern =\n [ regex \"a grand\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney . withValue 1000\n $ currencyOnly TTD\n }\n\nruleGrand :: Rule\nruleGrand = Rule\n { name = \" grand\"\n , pattern =\n [ Predicate isPositive\n , regex \"grand\"\n ]\n , prod = \\case\n (Token Numeral TNumeral.NumeralData{TNumeral.value = v}:_)\n -> Just . Token AmountOfMoney . withValue (1000 * v)\n $ currencyOnly TTD\n _ -> Nothing\n }\n\nruleDollarCoin :: Rule\nruleDollarCoin = Rule\n { name = \"dollar coin\"\n , pattern =\n [ regex \"(nickel|dime|quarter)s?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> do\n c <- HashMap.lookup (Text.toLower match) Helpers.dollarCoins\n Just . Token AmountOfMoney . withValue c $ currencyOnly TTD\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleAGrand\n , ruleGrand\n , ruleDollarCoin\n ]\n", "num_lines": 74} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.EN.US.Corpus\n ( allExamples\n , negativeExamples\n ) where\n\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\n\nimport Duckling.AmountOfMoney.Types\nimport Duckling.Testing.Types\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple USD 1000)\n [ \"a grand\"\n , \"1 grand\"\n ]\n , examples (simple USD 10000)\n [ \"10 grand\"\n , \"two hundred thousand nickels\"\n ]\n , examples (simple USD 1)\n [ \"four quarters\"\n , \"ten dimes\"\n , \"twenty nickels\"\n ]\n , examples (simple USD 0.1)\n [ \"dime\"\n , \"a dime\"\n , \"two nickels\"\n ]\n , examples (simple USD 0.25)\n [ \"quarter\"\n , \"a quarter\"\n , \"five nickels\"\n ]\n , examples (simple USD 0.05)\n [ \"nickel\"\n , \"a nickel\"\n ]\n ]\n\nnegativeExamples :: [Text]\nnegativeExamples =\n [ \"grand\"\n ]\n", "num_lines": 56} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.EN.US.Rules\n ( rules\n ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\n\nimport Duckling.AmountOfMoney.Helpers\nimport Duckling.AmountOfMoney.Types (Currency(..))\nimport Duckling.Numeral.Helpers (isPositive)\nimport Duckling.Regex.Types\nimport Duckling.Types\n\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\nimport qualified Duckling.AmountOfMoney.Helpers as Helpers\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleAGrand :: Rule\nruleAGrand = Rule\n { name = \"a grand\"\n , pattern =\n [ regex \"a grand\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney . withValue 1000 $ currencyOnly USD\n }\n\nruleGrand :: Rule\nruleGrand = Rule\n { name = \" grand\"\n , pattern =\n [ Predicate isPositive\n , regex \"grand\"\n ]\n , prod = \\case\n (Token Numeral TNumeral.NumeralData{TNumeral.value = v}:_)\n -> Just . Token AmountOfMoney . withValue (1000 * v) $ currencyOnly USD\n _ -> Nothing\n }\n\nruleDollarCoin :: Rule\nruleDollarCoin = Rule\n { name = \"dollar coin\"\n , pattern =\n [ regex \"(nickel|dime|quarter)s?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> do\n c <- HashMap.lookup (Text.toLower match) Helpers.dollarCoins\n Just . Token AmountOfMoney . withValue c $ currencyOnly USD\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleAGrand\n , ruleGrand\n , ruleDollarCoin\n ]\n", "num_lines": 72} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.EN.ZA.Corpus\n ( allExamples\n , negativeExamples\n ) where\n\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\n\nimport Duckling.AmountOfMoney.Types\nimport Duckling.Testing.Types\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple Dollar 1000)\n [ \"a grand\"\n , \"1 grand\"\n ]\n , examples (simple Dollar 10000)\n [ \"10 grand\"\n , \"two hundred thousand nickels\"\n ]\n , examples (simple Dollar 1)\n [ \"four quarters\"\n , \"ten dimes\"\n , \"twenty nickels\"\n ]\n , examples (simple Dollar 0.1)\n [ \"dime\"\n , \"a dime\"\n , \"two nickels\"\n ]\n , examples (simple Dollar 0.25)\n [ \"quarter\"\n , \"a quarter\"\n , \"five nickels\"\n ]\n , examples (simple Dollar 0.05)\n [ \"nickel\"\n , \"a nickel\"\n ]\n ]\n\nnegativeExamples :: [Text]\nnegativeExamples =\n [ \"grand\"\n ]\n", "num_lines": 56} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.EN.ZA.Rules\n ( rules\n ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\n\nimport Duckling.AmountOfMoney.Helpers\nimport Duckling.AmountOfMoney.Types (Currency(..))\nimport Duckling.Numeral.Helpers (isPositive)\nimport Duckling.Regex.Types\nimport Duckling.Types\n\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\nimport qualified Duckling.AmountOfMoney.Helpers as Helpers\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleAGrand :: Rule\nruleAGrand = Rule\n { name = \"a grand\"\n , pattern =\n [ regex \"a grand\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney . withValue 1000\n $ currencyOnly Dollar\n }\n\nruleGrand :: Rule\nruleGrand = Rule\n { name = \" grand\"\n , pattern =\n [ Predicate isPositive\n , regex \"grand\"\n ]\n , prod = \\case\n (Token Numeral TNumeral.NumeralData{TNumeral.value = v}:_)\n -> Just . Token AmountOfMoney . withValue (1000 * v)\n $ currencyOnly Dollar\n _ -> Nothing\n }\n\nruleDollarCoin :: Rule\nruleDollarCoin = Rule\n { name = \"dollar coin\"\n , pattern =\n [ regex \"(nickel|dime|quarter)s?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> do\n c <- HashMap.lookup (Text.toLower match) Helpers.dollarCoins\n Just . Token AmountOfMoney . withValue c $ currencyOnly Dollar\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleAGrand\n , ruleGrand\n , ruleDollarCoin\n ]\n", "num_lines": 74} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.ES.Corpus\n ( corpus\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.AmountOfMoney.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale ES Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple Dollar 10)\n [ \"$10\"\n , \"10$\"\n , \"diez dollars\"\n , \"diez d\u00c3\u00b3lares\"\n ]\n , examples (simple Dollar 10000)\n [ \"$10.000\"\n , \"10K$\"\n , \"$10k\"\n ]\n , examples (simple USD 1.23)\n [ \"USD1,23\"\n ]\n , examples (simple EUR 20)\n [ \"20\u00e2\u201a\u00ac\"\n , \"20 euros\"\n , \"20 Euro\"\n , \"20 Euros\"\n , \"EUR 20\"\n ]\n , examples (simple EUR 29.99)\n [ \"EUR29,99\"\n ]\n , examples (simple Pound 9)\n [ \"\u00c2\u00a39\"\n , \"nueve pounds\"\n , \"9 libras\"\n ]\n , examples (simple GBP 3.01)\n [ \"GBP3,01\"\n , \"GBP 3,01\"\n , \"3 gbp 1 centavo\"\n , \"3 gbp y 1 centavo\"\n ]\n , examples (simple PTS 15)\n [ \"15 Pt\"\n , \"15pta\"\n , \"15Ptas\"\n ]\n , examples (between Dollar (10, 20))\n [ \"entre 10 y 20 d\u00c3\u00b3lares\"\n , \"de $10 y $20\"\n , \"$10 - 20 d\u00c3\u00b3lares\"\n , \"10 - 20 $\"\n ]\n , examples (under Dollar 10)\n [ \"menos de 10 d\u00c3\u00b3lares\"\n , \"no m\u00c3\u00a1s de $10\"\n ]\n , examples (above Dollar 10)\n [ \"no menos de 10 d\u00c3\u00b3lares\"\n , \"m\u00c3\u00a1s de $10\"\n ]\n ]\n", "num_lines": 82} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.ES.Rules\n ( rules\n ) where\n\nimport Data.Maybe\nimport Data.String\nimport Prelude\n\nimport Duckling.AmountOfMoney.Helpers\nimport Duckling.AmountOfMoney.Types (Currency(..), AmountOfMoneyData (..))\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers (isNatural, isPositive)\nimport Duckling.Numeral.Types (NumeralData (..))\nimport Duckling.Types\nimport qualified Duckling.AmountOfMoney.Types as TAmountOfMoney\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleUnitAmount :: Rule\nruleUnitAmount = Rule\n { name = \" \"\n , pattern =\n [ Predicate isCurrencyOnly\n , Predicate isPositive\n ]\n , prod = \\case\n (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.currency = c}:\n Token Numeral NumeralData{TNumeral.value = v}:\n _) -> Just . Token AmountOfMoney . withValue v $ currencyOnly c\n _ -> Nothing\n }\n\nruleDollar :: Rule\nruleDollar = Rule\n { name = \"dollar\"\n , pattern =\n [ regex \"d(\u00c3\u00b3|o)lar(es)?\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly Dollar\n }\n\nruleCent :: Rule\nruleCent = Rule\n { name = \"cent\"\n , pattern =\n [ regex \"centavos?\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly Cent\n }\n\nrulePounds :: Rule\nrulePounds = Rule\n { name = \"\u00c2\u00a3\"\n , pattern =\n [ regex \"(pound|libra)s?\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly Pound\n }\n\nruleIntersectAndNumeral :: Rule\nruleIntersectAndNumeral = Rule\n { name = \"intersect (and number)\"\n , pattern =\n [ Predicate isWithoutCents\n , regex \"y\"\n , Predicate isNatural\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n _:\n Token Numeral NumeralData{TNumeral.value = c}:\n _) -> Just . Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nruleIntersectXCents :: Rule\nruleIntersectXCents = Rule\n { name = \"intersect (X cents)\"\n , pattern =\n [ Predicate isWithoutCents\n , Predicate isCents\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just c}:\n _) -> Just . Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nruleIntersectAndXCents :: Rule\nruleIntersectAndXCents = Rule\n { name = \"intersect (and X cents)\"\n , pattern =\n [ Predicate isWithoutCents\n , regex \"y\"\n , Predicate isCents\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just c}:\n _) -> Just . Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nruleIntersect :: Rule\nruleIntersect = Rule\n { name = \"intersect\"\n , pattern =\n [ Predicate isWithoutCents\n , Predicate isNatural\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n Token Numeral NumeralData{TNumeral.value = c}:\n _) -> Just . Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nruleIntervalBetweenNumeral :: Rule\nruleIntervalBetweenNumeral = Rule\n { name = \"between|from to|and \"\n , pattern =\n [ regex \"de|entre\"\n , Predicate isPositive\n , regex \"a|y\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\case\n (_:\n Token Numeral NumeralData{TNumeral.value = from}:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c}:\n _) | from < to ->\n Just $ Token AmountOfMoney $ withInterval (from, to) $ currencyOnly c\n _ -> Nothing\n }\n\nruleIntervalBetween :: Rule\nruleIntervalBetween = Rule\n { name = \"between|from to|and \"\n , pattern =\n [ regex \"de|entre\"\n , Predicate isSimpleAmountOfMoney\n , regex \"a|y\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\case\n (_:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just from,\n TAmountOfMoney.currency = c1}:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c2}:\n _) | from < to && c1 == c2 ->\n Just $ Token AmountOfMoney $ withInterval (from, to) $ currencyOnly c1\n _ -> Nothing\n }\n\nruleIntervalNumeralDash :: Rule\nruleIntervalNumeralDash = Rule\n { name = \" - \"\n , pattern =\n [ Predicate isNatural\n , regex \"-\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = from}:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c}:\n _) | from < to->\n Just $ Token AmountOfMoney $ withInterval (from, to) $ currencyOnly c\n _ -> Nothing\n }\n\nruleIntervalDash :: Rule\nruleIntervalDash = Rule\n { name = \" - \"\n , pattern =\n [ Predicate isSimpleAmountOfMoney\n , regex \"-\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\case\n (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just from,\n TAmountOfMoney.currency = c1}:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c2}:\n _) | from < to && c1 == c2 ->\n Just $ Token AmountOfMoney $ withInterval (from, to) $ currencyOnly c1\n _ -> Nothing\n }\n\nruleIntervalMax :: Rule\nruleIntervalMax = Rule\n { name = \"less/no more than \"\n , pattern =\n [ regex \"menos de|no m\u00c3\u00a1s de\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\case\n (_:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c}:\n _) -> Just $ Token AmountOfMoney $ withMax to $ currencyOnly c\n _ -> Nothing\n }\n\nruleIntervalMin :: Rule\nruleIntervalMin = Rule\n { name = \"no less/more than \"\n , pattern =\n [ regex \"m\u00c3\u00a1s de|no menos de\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\case\n (_:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c}:\n _) -> Just $ Token AmountOfMoney $ withMin to $ currencyOnly c\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleUnitAmount\n , ruleCent\n , ruleDollar\n , ruleIntersect\n , ruleIntersectAndNumeral\n , ruleIntersectAndXCents\n , ruleIntersectXCents\n , rulePounds\n , ruleIntervalBetweenNumeral\n , ruleIntervalBetween\n , ruleIntervalNumeralDash\n , ruleIntervalDash\n , ruleIntervalMax\n , ruleIntervalMin\n ]\n", "num_lines": 255} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.FR.Corpus\n ( corpus\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.AmountOfMoney.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale FR Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple Dollar 10)\n [ \"$10\"\n , \"10$\"\n , \"dix dollars\"\n ]\n , examples (simple Dollar 10000)\n [ \"$10.000\"\n , \"10K$\"\n , \"$10k\"\n , \"10 000 dollars\"\n , \"10 000,00 $\"\n ]\n , examples (simple USD 1.23)\n [ \"USD1,23\"\n , \"1 USD et 23 centimes\"\n , \"1 USD 23 cents\"\n ]\n , examples (simple EUR 20)\n [ \"20\u00e2\u201a\u00ac\"\n , \"20 euros\"\n , \"20 Euro\"\n , \"20 Euros\"\n , \"EUR 20\"\n ]\n , examples (simple EUR 29.99)\n [ \"EUR29,99\"\n ]\n , examples (simple Unnamed 3)\n [ \"3 balles\"\n , \"\u00c3\u00a0 peu pr\u00c3\u00a8s 3 pouloutes\"\n ]\n , examples (simple Pound 9)\n [ \"exactement \u00c2\u00a39\"\n , \"neuf pounds\"\n , \"quasi neuf livres\"\n ]\n , examples (simple GBP 3.01)\n [ \"GBP3,01\"\n , \"GBP 3,01\"\n ]\n , examples (simple ILS 10)\n [ \"dix shekels\"\n ]\n , examples (simple Rial 10)\n [ \"dix rials\"\n ]\n , examples (simple Riyal 10)\n [ \"dix riyals\"\n ]\n , examples (between EUR (10, 20))\n [ \"entre 10 et 20 euro\"\n , \"entre 10 euro et 20 euro\"\n , \"10 - 20 euro\"\n , \"10 euro - 20 euro\"\n ]\n , examples (above EUR 10)\n [ \"au moins 10 euro\"\n , \"plus que 10 euros\"\n , \"plus de 10 euros\"\n ]\n , examples (under Dollar 10)\n [ \"en-dessous de 10 dollars\"\n , \"moins de 10 dollars\"\n , \"pas plus de 10 dollars\"\n ]\n ]\n", "num_lines": 93} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.FR.Rules\n ( rules\n ) where\n\nimport Data.Maybe\nimport Data.String\nimport Prelude\n\nimport Duckling.AmountOfMoney.Helpers\nimport Duckling.AmountOfMoney.Types (Currency (..), AmountOfMoneyData (..))\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers (isNatural, isPositive)\nimport Duckling.Numeral.Types (NumeralData (..))\nimport Duckling.Types\nimport qualified Duckling.AmountOfMoney.Types as TAmountOfMoney\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleUnitAmount :: Rule\nruleUnitAmount = Rule\n { name = \" \"\n , pattern =\n [ Predicate isCurrencyOnly\n , Predicate isPositive\n ]\n , prod = \\case\n (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.currency = c}:\n Token Numeral NumeralData{TNumeral.value = v}:\n _) -> Just . Token AmountOfMoney . withValue v $ currencyOnly c\n _ -> Nothing\n }\n\nruleIntersectAndNumeral :: Rule\nruleIntersectAndNumeral = Rule\n { name = \"intersect (and number)\"\n , pattern =\n [ Predicate isWithoutCents\n , regex \"et\"\n , Predicate isNatural\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n _:\n Token Numeral NumeralData{TNumeral.value = c}:\n _) -> Just . Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nrulePrecision :: Rule\nrulePrecision = Rule\n { name = \"precision\"\n , pattern =\n [ regex \"exactement|quasi|plus ou moins|environ|autour de|(a|\u00c3\u00a0) peu pr(e|\u00c3\u00a8)s\"\n , Predicate isMoneyWithValue\n ]\n , prod = \\tokens -> case tokens of\n (_:token:_) -> Just token\n _ -> Nothing\n }\n\nruleCent :: Rule\nruleCent = Rule\n { name = \"cent\"\n , pattern =\n [ regex \"cent(ime)?s?\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly Cent\n }\n\nruleIntersectXCents :: Rule\nruleIntersectXCents = Rule\n { name = \"intersect (X cents)\"\n , pattern =\n [ Predicate isWithoutCents\n , Predicate isCents\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just c}:\n _) -> Just . Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nruleIntervalBetweenNumeral :: Rule\nruleIntervalBetweenNumeral = Rule\n { name = \"between|from to|and \"\n , pattern =\n [ regex \"entre\"\n , Predicate isPositive\n , regex \"et\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\tokens -> case tokens of\n (_:\n Token Numeral NumeralData{TNumeral.value = from}:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c}:\n _) | from < to ->\n Just . Token AmountOfMoney . withInterval (from, to) $ currencyOnly c\n _ -> Nothing\n }\n\n\nruleIntervalBetween :: Rule\nruleIntervalBetween = Rule\n { name = \"between|from to|and \"\n , pattern =\n [ regex \"entre\"\n , Predicate isSimpleAmountOfMoney\n , regex \"et\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\tokens -> case tokens of\n (_:\n Token AmountOfMoney AmountOfMoneyData {\n TAmountOfMoney.value = Just from,\n TAmountOfMoney.currency = c1\n }:\n _:\n Token AmountOfMoney AmountOfMoneyData {\n TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c2\n }:\n _) | c1 == c2, from < to ->\n Just . Token AmountOfMoney . withInterval (from, to) $ currencyOnly c1\n _ -> Nothing\n }\n\n\nruleIntervalNumeralDash :: Rule\nruleIntervalNumeralDash = Rule\n { name = \" - \"\n , pattern =\n [ Predicate isNatural\n , regex \"-\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = from}:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c}:\n _) | from < to ->\n Just . Token AmountOfMoney . withInterval (from, to) $ currencyOnly c\n _ -> Nothing\n }\n\nruleIntervalDash :: Rule\nruleIntervalDash = Rule\n { name = \" - \"\n , pattern =\n [ Predicate isSimpleAmountOfMoney\n , regex \"-\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just from,\n TAmountOfMoney.currency = c1}:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c2}:\n _) | from < to && c1 == c2 ->\n Just . Token AmountOfMoney . withInterval (from, to) $ currencyOnly c1\n _ -> Nothing\n }\n\nruleIntervalMax :: Rule\nruleIntervalMax = Rule\n { name = \"under/less/lower/no more than \"\n , pattern =\n [ regex \"(moins|pas plus|en-dessous) de\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\tokens -> case tokens of\n (_:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c}:\n _) -> Just . Token AmountOfMoney . withMax to $ currencyOnly c\n _ -> Nothing\n }\n\nruleIntervalMin :: Rule\nruleIntervalMin = Rule\n { name = \"over/above/at least/more than \"\n , pattern =\n [ regex \"plus (que|de)|au moins\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\tokens -> case tokens of\n (_:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c}:\n _) -> Just . Token AmountOfMoney . withMin to $ currencyOnly c\n _ -> Nothing\n }\n\nrulePounds :: Rule\nrulePounds = Rule\n { name = \"\u00c2\u00a3\"\n , pattern =\n [ regex \"(livre|pound)s?\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly Pound\n }\n\nruleIntersectAndXCents :: Rule\nruleIntersectAndXCents = Rule\n { name = \"intersect (and X cents)\"\n , pattern =\n [ Predicate isWithoutCents\n , regex \"et\"\n , Predicate isCents\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just c}:\n _) -> Just . Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nruleIntersect :: Rule\nruleIntersect = Rule\n { name = \"intersect\"\n , pattern =\n [ Predicate isWithoutCents\n , Predicate isNatural\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n Token Numeral NumeralData{TNumeral.value = c}:\n _) -> Just . Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nruleUnnamedCurrency :: Rule\nruleUnnamedCurrency = Rule\n { name = \"unnamed currencyOnly\"\n , pattern =\n [ regex \"(balle|pouloute)s?\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly Unnamed\n }\n\nrules :: [Rule]\nrules =\n [ ruleUnitAmount\n , ruleCent\n , ruleIntersect\n , ruleIntersectAndNumeral\n , ruleIntersectAndXCents\n , ruleIntersectXCents\n , ruleIntervalBetween\n , ruleIntervalBetweenNumeral\n , ruleIntervalDash\n , ruleIntervalMax\n , ruleIntervalMin\n , ruleIntervalNumeralDash\n , rulePounds\n , rulePrecision\n , ruleUnnamedCurrency\n ]\n", "num_lines": 274} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.GA.Corpus\n ( corpus\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.AmountOfMoney.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale GA Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple Dollar 10)\n [ \"$10\"\n , \"10$\"\n , \"deich dollair\"\n ]\n , examples (simple Cent 10)\n [ \"deich ceinteanna\"\n ]\n , examples (simple Dollar 10000)\n [ \"$10,000\"\n , \"10K$\"\n , \"$10k\"\n ]\n , examples (simple EUR 10000)\n [ \"\u00e2\u201a\u00ac10,000\"\n , \"10K\u00e2\u201a\u00ac\"\n , \"\u00e2\u201a\u00ac10k\"\n ]\n , examples (simple USD 1.23)\n [ \"USD1.23\"\n ]\n , examples (simple Dollar 2.23)\n [ \"2 dhollair agus 23 ceinteanna\"\n , \"dh\u00c3\u00a1 dhollair 23 ceinteanna\"\n , \"2 dhollair 23\"\n , \"dh\u00c3\u00a1 dhollair agus 23\"\n ]\n , examples (simple EUR 20)\n [ \"20\u00e2\u201a\u00ac\"\n , \"20 euros\"\n , \"20 Euro\"\n , \"20 Euros\"\n , \"EUR 20\"\n ]\n , examples (simple EUR 29.99)\n [ \"EUR29.99\"\n ]\n , examples (simple INR 20)\n [ \"Rs. 20\"\n , \"Rs 20\"\n , \"20 R\u00c3\u00bapa\u00c3\u00ad\"\n , \"20Rs\"\n , \"Rs20\"\n ]\n , examples (simple INR 20.43)\n [ \"20 Rupees 43\"\n , \"fiche r\u00c3\u00bapa\u00c3\u00ad 43\"\n ]\n , examples (simple INR 33)\n [ \"INR33\"\n ]\n , examples (simple Pound 9)\n [ \"\u00c2\u00a39\"\n , \"naoi bpunt\"\n ]\n , examples (simple GBP 3.01)\n [ \"GBP3.01\"\n , \"GBP 3.01\"\n ]\n ]\n", "num_lines": 87} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.GA.Rules\n ( rules\n ) where\n\nimport Data.Maybe\nimport Data.String\nimport Prelude\n\nimport Duckling.AmountOfMoney.Helpers\nimport Duckling.AmountOfMoney.Types (Currency (..), AmountOfMoneyData (..))\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers (isNatural, isPositive)\nimport Duckling.Numeral.Types (NumeralData (..))\nimport Duckling.Types\nimport qualified Duckling.AmountOfMoney.Types as TAmountOfMoney\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleUnitAmount :: Rule\nruleUnitAmount = Rule\n { name = \" \"\n , pattern =\n [ Predicate isCurrencyOnly\n , Predicate isPositive\n ]\n , prod = \\case\n (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.currency = c}:\n Token Numeral NumeralData{TNumeral.value = v}:\n _) -> Just . Token AmountOfMoney . withValue v $ currencyOnly c\n _ -> Nothing\n }\n\nruleDollar :: Rule\nruleDollar = Rule\n { name = \"$\"\n , pattern =\n [ regex \"n?dh?oll?ai?rs?\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly Dollar\n }\n\nruleCent :: Rule\nruleCent = Rule\n { name = \"cent\"\n , pattern =\n [ regex \"cents?|g?ch?eint(eanna)?\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly Cent\n }\n\nruleThartArAmountofmoney :: Rule\nruleThartArAmountofmoney = Rule\n { name = \"thart ar \"\n , pattern =\n [ regex \"thart( ar)?|beagnach|breis (is|agus)\"\n , Predicate isMoneyWithValue\n ]\n , prod = \\tokens -> case tokens of\n (_:token:_) -> Just token\n _ -> Nothing\n }\n\nruleIntersectXCents :: Rule\nruleIntersectXCents = Rule\n { name = \"intersect (X cents)\"\n , pattern =\n [ Predicate isWithoutCents\n , Predicate isCents\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just c}:\n _) -> Just . Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nrulePounds :: Rule\nrulePounds = Rule\n { name = \"\u00c2\u00a3\"\n , pattern =\n [ regex \"pounds?|b?ph?unt\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly Pound\n }\n\nruleIntersectAndXCents :: Rule\nruleIntersectAndXCents = Rule\n { name = \"intersect (and X cents)\"\n , pattern =\n [ Predicate isWithoutCents\n , regex \"agus|is\"\n , Predicate isCents\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just c}:\n _) -> Just . Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nruleIntersect :: Rule\nruleIntersect = Rule\n { name = \"intersect\"\n , pattern =\n [ Predicate isWithoutCents\n , Predicate isNatural\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n Token Numeral NumeralData{TNumeral.value = c}:\n _) -> Just . Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nruleInr :: Rule\nruleInr = Rule\n { name = \"INR\"\n , pattern =\n [ regex \"r(\u00c3\u00ba|u)pa(\u00c3\u00ad|i)\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly INR\n }\n\nruleIntersectAgusNumeral :: Rule\nruleIntersectAgusNumeral = Rule\n { name = \"intersect (agus number)\"\n , pattern =\n [ Predicate isWithoutCents\n , regex \"agus|is\"\n , Predicate isNatural\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n _:\n Token Numeral NumeralData{TNumeral.value = c}:\n _) -> Just . Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nruleAmountofmoneyGlan :: Rule\nruleAmountofmoneyGlan = Rule\n { name = \" glan\"\n , pattern =\n [ Predicate isMoneyWithValue\n , regex \"glan|baileach|(go )?d(\u00c3\u00ad|i)reach\"\n ]\n , prod = \\tokens -> case tokens of\n (token:_) -> Just token\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleUnitAmount\n , ruleAmountofmoneyGlan\n , ruleCent\n , ruleDollar\n , ruleInr\n , ruleIntersect\n , ruleIntersectAgusNumeral\n , ruleIntersectAndXCents\n , ruleIntersectXCents\n , rulePounds\n , ruleThartArAmountofmoney\n ]\n", "num_lines": 177} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.HR.Rules\n ( rules\n ) where\n\nimport Data.Maybe\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\nimport qualified Data.Text as Text\n\nimport Duckling.AmountOfMoney.Helpers\nimport Duckling.AmountOfMoney.Types (Currency(..), AmountOfMoneyData (..))\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers (isNatural, isPositive)\nimport Duckling.Numeral.Types (NumeralData (..))\nimport Duckling.Regex.Types\nimport Duckling.Types\nimport qualified Duckling.AmountOfMoney.Types as TAmountOfMoney\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleACurrency :: Rule\nruleACurrency = Rule\n { name = \"a \"\n , pattern =\n [ regex \"jed(an|na|no)\"\n , Predicate isCurrencyOnly\n ]\n , prod = \\tokens -> case tokens of\n (_:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.currency = c}:\n _) -> Just . Token AmountOfMoney $ withValue 1 $ currencyOnly c\n _ -> Nothing\n }\n\nruleUnitAmount :: Rule\nruleUnitAmount = Rule\n { name = \" \"\n , pattern =\n [ Predicate isCurrencyOnly\n , Predicate isPositive\n ]\n , prod = \\case\n (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.currency = c}:\n Token Numeral NumeralData{TNumeral.value = v}:\n _) -> Just . Token AmountOfMoney . withValue v $ currencyOnly c\n _ -> Nothing\n }\n\nruleIntersectAndNumber :: Rule\nruleIntersectAndNumber = Rule\n { name = \"intersect (and number)\"\n , pattern =\n [ Predicate isWithoutCents\n , regex \"i\"\n , Predicate isNatural\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n _:\n Token Numeral NumeralData{TNumeral.value = c}:\n _) -> Just . Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nruleSar :: Rule\nruleSar = Rule\n { name = \"SAR\"\n , pattern =\n [ regex \"saudijskirijal|saudi rijal?\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly SAR\n }\n\nruleDollar :: Rule\nruleDollar = Rule\n { name = \"$\"\n , pattern =\n [ regex \"dolar(a|i|e)?\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly Dollar\n }\n\nruleCent :: Rule\nruleCent = Rule\n { name = \"cent\"\n , pattern =\n [ regex \"cent(i|a)?|penij(i|a)?|c|\u00c2\u00a2|lp|lip(a|e)\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly Cent\n }\n\nruleIntersectIXLipa :: Rule\nruleIntersectIXLipa = Rule\n { name = \"intersect (i X lipa)\"\n , pattern =\n [ Predicate isWithoutCents\n , regex \"i\"\n , Predicate isCents\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just c}:\n _) -> Just . Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nruleIntersectXCents :: Rule\nruleIntersectXCents = Rule\n { name = \"intersect (X cents)\"\n , pattern =\n [ Predicate isWithoutCents\n , Predicate isCents\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just c}:\n _) -> Just . Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nrulePound :: Rule\nrulePound = Rule\n { name = \"\u00c2\u00a3\"\n , pattern =\n [ regex \"funt(a|e|i)?\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly Pound\n }\n\nruleHrk :: Rule\nruleHrk = Rule\n { name = \"HRK\"\n , pattern =\n [ regex \"kn|(hrvatsk(a|ih|e) )?kun(a|e)\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly HRK\n }\n\nruleIntersect :: Rule\nruleIntersect = Rule\n { name = \"intersect\"\n , pattern =\n [ Predicate isWithoutCents\n , Predicate isNatural\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n Token Numeral NumeralData{TNumeral.value = c}:\n _) -> Just . Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nruleOtherPounds :: Rule\nruleOtherPounds = Rule\n { name = \"other pounds\"\n , pattern =\n [ regex \"(egipatska|libanonska) ?funta\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of\n \"egipatska\" -> Just . Token AmountOfMoney $ currencyOnly EGP\n \"libanonska\" -> Just . Token AmountOfMoney $ currencyOnly LBP\n _ -> Nothing\n _ -> Nothing\n }\n\nruleInr :: Rule\nruleInr = Rule\n { name = \"INR\"\n , pattern =\n [ regex \"rupija?\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly INR\n }\n\nruleKwd :: Rule\nruleKwd = Rule\n { name = \"KWD\"\n , pattern =\n [ regex \"kuvajtski ?dinar\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly KWD\n }\n\nruleQar :: Rule\nruleQar = Rule\n { name = \"QAR\"\n , pattern =\n [ regex \"katarski(i| )rijal\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly QAR\n }\n\nruleAed :: Rule\nruleAed = Rule\n { name = \"AED\"\n , pattern =\n [ regex \"drahma?\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly AED\n }\n\nrulePrecision :: Rule\nrulePrecision = Rule\n { name = \"about|exactly \"\n , pattern =\n [ regex \"oko|otprilike|u blizini|skoro|pribli\u00c5\u00beno\"\n , Predicate isMoneyWithValue\n ]\n , prod = \\tokens -> case tokens of\n (_:token:_) -> Just token\n _ -> Nothing\n }\n\nruleIntervalNumeralDash :: Rule\nruleIntervalNumeralDash = Rule\n { name = \" - \"\n , pattern =\n [ Predicate isNatural\n , regex \"-\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = from}:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c}:\n _) | from < to->\n Just . Token AmountOfMoney . withInterval (from, to) $ currencyOnly c\n _ -> Nothing\n }\n\nruleIntervalDash :: Rule\nruleIntervalDash = Rule\n { name = \" - \"\n , pattern =\n [ Predicate isSimpleAmountOfMoney\n , regex \"-\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just from,\n TAmountOfMoney.currency = c1}:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c2}:\n _) | from < to && c1 == c2 ->\n Just . Token AmountOfMoney . withInterval (from, to) $ currencyOnly c1\n _ -> Nothing\n }\n\nruleIntervalBetweenNumeral1 :: Rule\nruleIntervalBetweenNumeral1 = Rule\n { name = \"between|from to|and \"\n , pattern =\n [ regex \"od|otprilike|pribli\u00c5\u00beno\"\n , Predicate isPositive\n , regex \"do\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\tokens -> case tokens of\n (_:\n Token Numeral NumeralData{TNumeral.value = from}:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c}:\n _) | from < to ->\n Just . Token AmountOfMoney . withInterval (from, to) $ currencyOnly c\n _ -> Nothing\n }\n\nruleIntervalBetweenNumeral2 :: Rule\nruleIntervalBetweenNumeral2 = Rule\n { name = \"between|from to|and \"\n , pattern =\n [ regex \"izmedju\"\n , Predicate isPositive\n , regex \"i\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\tokens -> case tokens of\n (_:\n Token Numeral NumeralData{TNumeral.value = from}:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c}:\n _) | from < to ->\n Just . Token AmountOfMoney . withInterval (from, to) $ currencyOnly c\n _ -> Nothing\n }\n\nruleIntervalBetween1 :: Rule\nruleIntervalBetween1 = Rule\n { name = \"between|from to|and \"\n , pattern =\n [ regex \"od|otprilike\"\n , Predicate isSimpleAmountOfMoney\n , regex \"do\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\tokens -> case tokens of\n (_:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just from,\n TAmountOfMoney.currency = c1}:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c2}:\n _) | from < to && c1 == c2 ->\n Just . Token AmountOfMoney . withInterval (from, to) $ currencyOnly c1\n _ -> Nothing\n }\n\nruleIntervalBetween2 :: Rule\nruleIntervalBetween2 = Rule\n { name = \"between|from to|and \"\n , pattern =\n [ regex \"izmedju\"\n , Predicate isSimpleAmountOfMoney\n , regex \"i\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\tokens -> case tokens of\n (_:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just from,\n TAmountOfMoney.currency = c1}:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c2}:\n _) | from < to && c1 == c2 ->\n Just . Token AmountOfMoney . withInterval (from, to) $ currencyOnly c1\n _ -> Nothing\n }\n\nruleIntervalMin :: Rule\nruleIntervalMin = Rule\n { name = \"over/above/at least/more than \"\n , pattern =\n [ regex \"vi\u00c5\u00a1e od|najmanje|preko|iznad\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\tokens -> case tokens of\n (_:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c}:\n _) -> Just . Token AmountOfMoney . withMin to $ currencyOnly c\n _ -> Nothing\n }\n\nruleIntervalMax :: Rule\nruleIntervalMax = Rule\n { name = \"under/less/lower/no more than \"\n , pattern =\n [ regex \"ispod|manje od\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\tokens -> case tokens of\n (_:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c}:\n _) -> Just . Token AmountOfMoney . withMax to $ currencyOnly c\n _ -> Nothing\n }\n\n\nrules :: [Rule]\nrules =\n [ ruleACurrency\n , ruleUnitAmount\n , ruleDollar\n , rulePound\n , ruleOtherPounds\n , ruleAed\n , ruleCent\n , ruleHrk\n , ruleInr\n , ruleIntersect\n , ruleIntersectAndNumber\n , ruleIntersectIXLipa\n , ruleIntersectXCents\n , ruleKwd\n , ruleQar\n , ruleSar\n , rulePrecision\n , ruleIntervalNumeralDash\n , ruleIntervalDash\n , ruleIntervalBetweenNumeral1\n , ruleIntervalBetweenNumeral2\n , ruleIntervalBetween1\n , ruleIntervalBetween2\n , ruleIntervalMin\n , ruleIntervalMax\n ]\n", "num_lines": 404} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.ID.Corpus\n ( corpus\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.AmountOfMoney.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale ID Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple Dollar 10)\n [ \"$10\"\n , \"10$\"\n , \"sepuluh dolar\"\n ]\n , examples (simple Dollar 10000)\n [ \"$10.000\"\n , \"10K$\"\n , \"$10k\"\n ]\n , examples (simple USD 1.23)\n [ \"USD1,23\"\n ]\n , examples (simple Dollar 2)\n [ \"2 dolar\"\n , \"dua dolar\"\n ]\n , examples (simple EUR 20)\n [ \"20\u00e2\u201a\u00ac\"\n , \"20 euros\"\n , \"20 Euro\"\n , \"20 Euros\"\n , \"EUR 20\"\n , \"dua puluh Euro\"\n ]\n , examples (simple EUR 29.99)\n [ \"EUR29,99\"\n ]\n , examples (simple IDR 315)\n [ \"Rp. 315,00\"\n ]\n , examples (simple IDR 20)\n [ \"Rp 20\"\n , \"20 Rupiah\"\n , \"20Rp\"\n , \"Rp20\"\n ]\n , examples (simple IDR 33000)\n [ \"IDR33000\"\n , \"IDR 33.000\"\n ]\n , examples (simple Pound 9)\n [ \"\u00c2\u00a39\"\n , \"sembilan pound\"\n , \"sembilan pound sterling\"\n ]\n , examples (simple GBP 3.01)\n [ \"GBP3,01\"\n , \"GBP 3,01\"\n ]\n , examples (simple JPY 10)\n [ \"10 yen\"\n , \"10\u00c2\u00a5\"\n , \"10 \u00c2\u00a5.\"\n ]\n , examples (between Dollar(10, 20))\n [ \"antara 10 sampai 20 dolar\"\n , \"dari 10 dolar sampai 20 dolar\"\n , \"sekitar 10 sampai 20 dolar\"\n , \"antara 10 hingga 20 dolar\"\n , \"sekitar 10 dolar hingga 20 dolar\"\n , \"kira-kira 10-20 dolar\"\n , \"10-20 dolar\"\n ]\n , examples (between IDR(1000, 10000))\n [ \"antara Rp1000 sampai Rp10000\"\n , \"dari 1000 Rupiah hingga 10000 Rupiah\"\n , \"sekitar 1000 sampai 10000 Rupiah\"\n , \"1000-10000 Rupiah\"\n , \"kira-kira Rp1000 sampai Rp10000\"\n , \"dari Rp1.000 sampai Rp10.000\"\n , \"antara 1.000 hingga 10.000 Rupiah\"\n , \"kira-kira 1.000-10.000 Rupiah\"\n , \"sekitar 1.000 hingga 10.000 Rupiah\"\n ]\n , examples (under EUR 7)\n [ \"kurang dari 7 euro\"\n , \"di bawah EUR 7\"\n , \"tidak sampai 7 euro\"\n , \"lebih murah dari EUR 7\"\n ]\n , examples (under IDR 500)\n [ \"kurang dari 500 Rupiah\"\n , \"tidak sampai Rp500\"\n , \"di bawah Rp 500\"\n , \"lebih murah dari 500 rupiah\"\n ]\n , examples (above USD 1.42)\n [ \"di atas USD1,42\"\n , \"lebih dari USD1,42\"\n , \"melebihi USD1,42\"\n , \"melewati USD1,42\"\n ]\n , examples (above IDR 33000)\n [ \"di atas 33.000 Rupiah\"\n , \"lebih dari Rp33000\"\n , \"melebihi Rp33.000\"\n , \"melewati 33000 rupiah\"\n ]\n ]\n", "num_lines": 127} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.ID.Rules\n ( rules\n ) where\n\nimport Data.Maybe\nimport Data.String\nimport Prelude\n\nimport Duckling.AmountOfMoney.Helpers\nimport Duckling.AmountOfMoney.Types (Currency(..), AmountOfMoneyData(..))\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers (isNatural, isPositive)\nimport Duckling.Numeral.Types (NumeralData (..))\nimport Duckling.Types\nimport qualified Duckling.AmountOfMoney.Types as TAmountOfMoney\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleUnitAmount :: Rule\nruleUnitAmount = Rule\n { name = \" \"\n , pattern =\n [ Predicate isCurrencyOnly\n , Predicate isPositive\n ]\n , prod = \\case\n (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.currency = c}:\n Token Numeral NumeralData{TNumeral.value = v}:\n _) -> Just . Token AmountOfMoney . withValue v $ currencyOnly c\n _ -> Nothing\n }\n\nruleDollar :: Rule\nruleDollar = Rule\n { name = \"$\"\n , pattern =\n [ regex \"dolar?\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly Dollar\n }\n\nruleIdr :: Rule\nruleIdr = Rule\n { name = \"IDR\"\n , pattern =\n [ regex \"rp\\\\.?|rupiah\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly IDR\n }\n\nrulePounds :: Rule\nrulePounds = Rule\n { name = \"\u00c2\u00a3\"\n , pattern =\n [ regex \"pound( sterling)?\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly Pound\n }\n\nruleIntersect :: Rule\nruleIntersect = Rule\n { name = \"intersect\"\n , pattern =\n [ Predicate isWithoutCents\n , Predicate isNatural\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n Token Numeral NumeralData{TNumeral.value = c}:\n _) -> Just . Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nruleJpy :: Rule\nruleJpy = Rule\n { name = \"JPY\"\n , pattern =\n [ regex \"\u00c2\u00a5\\\\.\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly JPY\n }\n\nrulePrecision :: Rule\nrulePrecision = Rule\n { name = \"about|exactly \"\n , pattern =\n [ regex \"tepatnya|kira-kira|sekitar|hampir\"\n , Predicate isMoneyWithValue\n ]\n , prod = \\case\n (_:token:_) -> Just token\n _ -> Nothing\n }\n\nruleIntervalBetweenNumeral :: Rule\nruleIntervalBetweenNumeral = Rule\n { name = \"between|from to|and \"\n , pattern =\n [ regex \"sekitar|dari|antara\"\n , Predicate isPositive\n , regex \"sampai|hingga\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\case\n (_:\n Token Numeral NumeralData{TNumeral.value = from}:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c}:\n _) | from < to ->\n Just . Token AmountOfMoney . withInterval (from, to) $ currencyOnly c\n _ -> Nothing\n }\n\nruleIntervalBetween :: Rule\nruleIntervalBetween = Rule\n { name = \"between|from to|and \"\n , pattern =\n [ regex \"sekitar|dari|antara|kira-kira\"\n , Predicate isSimpleAmountOfMoney\n , regex \"sampai|hingga\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\case\n (_:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just from,\n TAmountOfMoney.currency = c1}:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c2}:\n _) | from < to && c1 == c2 ->\n Just . Token AmountOfMoney . withInterval (from, to) $ currencyOnly c1\n _ -> Nothing\n }\n\nruleIntervalNumeralDash :: Rule\nruleIntervalNumeralDash = Rule\n { name = \" - \"\n , pattern =\n [ Predicate isNatural\n , regex \"\\\\-\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = from}:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c}:\n _) | from < to ->\n Just . Token AmountOfMoney . withInterval (from, to) $ currencyOnly c\n _ -> Nothing\n }\n\nruleIntervalDash :: Rule\nruleIntervalDash = Rule\n { name = \" - \"\n , pattern =\n [ Predicate isSimpleAmountOfMoney\n , regex \"\\\\-\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\case\n (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just from,\n TAmountOfMoney.currency = c1}:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c2}:\n _) | from < to && c1 == c2 ->\n Just . Token AmountOfMoney . withInterval (from, to) $ currencyOnly c1\n _ -> Nothing\n }\n\nruleIntervalMax :: Rule\nruleIntervalMax = Rule\n { name = \"under/less/lower/no more than \"\n , pattern =\n [ regex \"(kurang|lebih murah) dari|tidak sampai|di bawah\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\case\n (_:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c}:\n _) -> Just . Token AmountOfMoney . withMax to $ currencyOnly c\n _ -> Nothing\n }\n\nruleIntervalMin :: Rule\nruleIntervalMin = Rule\n { name = \"over/above/at least/more than \"\n , pattern =\n [ regex \"di atas|lebih dari|melebihi|melewati\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\case\n (_:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c}:\n _) -> Just . Token AmountOfMoney . withMin to $ currencyOnly c\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleUnitAmount\n , ruleDollar\n , ruleIdr\n , ruleIntersect\n , ruleJpy\n , rulePounds\n , rulePrecision\n , ruleIntervalBetweenNumeral\n , ruleIntervalBetween\n , ruleIntervalMax\n , ruleIntervalMin\n , ruleIntervalNumeralDash\n , ruleIntervalDash\n ]\n", "num_lines": 229} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.IT.Corpus\n ( corpus\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.AmountOfMoney.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale IT Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple Dollar 10)\n [ \"$10\"\n , \"10$\"\n , \"dieci dollari\"\n ]\n , examples (simple Dollar 10000)\n [ \"$10.000\"\n , \"10K$\"\n , \"$10k\"\n , \"10 000 dollari\"\n , \"10 000,00 $\"\n ]\n , examples (simple USD 1.23)\n [ \"USD1,23\"\n , \"1 USD e 23 centesimi\"\n , \"1 USD 23 centesimi\"\n ]\n , examples (simple EUR 20)\n [ \"20\u00e2\u201a\u00ac\"\n , \"20 euro\"\n , \"20 Euro\"\n , \"20 Euro\"\n , \"EUR 20\"\n ]\n , examples (simple EUR 29.99)\n [ \"EUR29,99\"\n ]\n , examples (simple Pound 9)\n [ \"nove sterline\"\n , \"quasi nove sterline\"\n ]\n , examples (simple GBP 3.01)\n [ \"GBP3,01\"\n , \"GBP 3,01\"\n ]\n , examples (between EUR (10, 20))\n [ \"tra 10 e 20 euro\"\n , \"tra 10 euro e 20 euro\"\n , \"10 - 20 euro\"\n , \"10 euro - 20 euro\"\n ]\n , examples (above EUR 10)\n [ \"almeno 10 euro\"\n , \"pi\u00c3\u00b9 di 10 euro\"\n , \"pi\u00c3\u00b9 di 10 euro\"\n ]\n , examples (under Dollar 10)\n [ \"meno di 10 dollari\"\n , \"non pi\u00c3\u00b9 di 10 dollari\"\n ]\n ]\n", "num_lines": 78} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.IT.Rules\n ( rules\n ) where\n\nimport Data.Maybe\nimport Data.String\nimport Prelude\nimport qualified Data.Text as Text\n\nimport Duckling.AmountOfMoney.Helpers\nimport Duckling.AmountOfMoney.Types (Currency (..), AmountOfMoneyData (..))\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers (isNatural, isPositive)\nimport Duckling.Numeral.Types (NumeralData (..))\nimport Duckling.Regex.Types (GroupMatch (..))\nimport Duckling.Types\nimport qualified Duckling.AmountOfMoney.Types as TAmountOfMoney\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleUnitAmount :: Rule\nruleUnitAmount = Rule\n { name = \" \"\n , pattern =\n [ Predicate isCurrencyOnly\n , Predicate isPositive\n ]\n , prod = \\case\n (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.currency = c}:\n Token Numeral NumeralData{TNumeral.value = v}:\n _) -> Just . Token AmountOfMoney . withValue v $ currencyOnly c\n _ -> Nothing\n }\n\nruleIntersectAndNumeral :: Rule\nruleIntersectAndNumeral = Rule\n { name = \"intersect (and number)\"\n , pattern =\n [ Predicate isWithoutCents\n , regex \"e\"\n , Predicate isNatural\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n _:\n Token Numeral NumeralData{TNumeral.value = c}:\n _) -> Just . Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nrulePrecision :: Rule\nrulePrecision = Rule\n { name = \"precision\"\n , pattern =\n [ regex \"esattamente|quasi|pi\u00c3\u00b9 o meno|circa\"\n , Predicate isMoneyWithValue\n ]\n , prod = \\tokens -> case tokens of\n (_:token:_) -> Just token\n _ -> Nothing\n }\n\nruleCent :: Rule\nruleCent = Rule\n { name = \"cent\"\n , pattern =\n [ regex \"cent(esim)i?o?\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly Cent\n }\n\nruleIntersectXCents :: Rule\nruleIntersectXCents = Rule\n { name = \"intersect (X cents)\"\n , pattern =\n [ Predicate isWithoutCents\n , Predicate isCents\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just c}:\n _) -> Just . Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nruleIntervalBetweenNumeral :: Rule\nruleIntervalBetweenNumeral = Rule\n { name = \"between|from to|and \"\n , pattern =\n [ regex \"tra\"\n , Predicate isPositive\n , regex \"e\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\tokens -> case tokens of\n (_:\n Token Numeral NumeralData{TNumeral.value = from}:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c}:\n _) | from < to ->\n Just . Token AmountOfMoney . withInterval (from, to) $ currencyOnly c\n _ -> Nothing\n }\n\n\nruleIntervalBetween :: Rule\nruleIntervalBetween = Rule\n { name = \"between|from to|and \"\n , pattern =\n [ regex \"tra\"\n , Predicate isSimpleAmountOfMoney\n , regex \"e\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\tokens -> case tokens of\n (_:\n Token AmountOfMoney AmountOfMoneyData {\n TAmountOfMoney.value = Just from,\n TAmountOfMoney.currency = c1\n }:\n _:\n Token AmountOfMoney AmountOfMoneyData {\n TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c2\n }:\n _) | c1 == c2, from < to ->\n Just . Token AmountOfMoney . withInterval (from, to) $ currencyOnly c1\n _ -> Nothing\n }\n\n\nruleIntervalNumeralDash :: Rule\nruleIntervalNumeralDash = Rule\n { name = \" - \"\n , pattern =\n [ Predicate isNatural\n , regex \"-\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = from}:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c}:\n _) | from < to ->\n Just . Token AmountOfMoney . withInterval (from, to) $ currencyOnly c\n _ -> Nothing\n }\n\nruleIntervalDash :: Rule\nruleIntervalDash = Rule\n { name = \" - \"\n , pattern =\n [ Predicate isSimpleAmountOfMoney\n , regex \"-\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just from,\n TAmountOfMoney.currency = c1}:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c2}:\n _) | from < to && c1 == c2 ->\n Just . Token AmountOfMoney . withInterval (from, to) $ currencyOnly c1\n _ -> Nothing\n }\n\nruleIntervalMax :: Rule\nruleIntervalMax = Rule\n { name = \"under/less/lower/no more than \"\n , pattern =\n [ regex \"(meno|non pi\u00c3\u00b9) di\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\tokens -> case tokens of\n (_:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c}:\n _) -> Just . Token AmountOfMoney . withMax to $ currencyOnly c\n _ -> Nothing\n }\n\nruleIntervalMin :: Rule\nruleIntervalMin = Rule\n { name = \"over/above/at least/more than \"\n , pattern =\n [ regex \"pi\u00c3\u00b9 di|almeno\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\tokens -> case tokens of\n (_:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c}:\n _) -> Just . Token AmountOfMoney . withMin to $ currencyOnly c\n _ -> Nothing\n }\n\nruleCurrencies :: Rule\nruleCurrencies = Rule\n { name = \"\u00c2\u00a3, $\"\n , pattern =\n [ regex \"(dollari|sterline)\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of\n \"dollari\" -> Just . Token AmountOfMoney $ currencyOnly Dollar\n \"sterline\" -> Just . Token AmountOfMoney $ currencyOnly Pound\n _ -> Nothing\n _ -> Nothing\n }\n\nruleIntersectAndXCents :: Rule\nruleIntersectAndXCents = Rule\n { name = \"intersect (and X cents)\"\n , pattern =\n [ Predicate isWithoutCents\n , regex \"e\"\n , Predicate isCents\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just c}:\n _) -> Just . Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nruleIntersect :: Rule\nruleIntersect = Rule\n { name = \"intersect\"\n , pattern =\n [ Predicate isWithoutCents\n , Predicate isNatural\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n Token Numeral NumeralData{TNumeral.value = c}:\n _) -> Just . Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleUnitAmount\n , ruleCent\n , ruleIntersect\n , ruleIntersectAndNumeral\n , ruleIntersectAndXCents\n , ruleIntersectXCents\n , ruleIntervalBetween\n , ruleIntervalBetweenNumeral\n , ruleIntervalDash\n , ruleIntervalMax\n , ruleIntervalMin\n , ruleIntervalNumeralDash\n , ruleCurrencies\n , rulePrecision\n ]\n", "num_lines": 271} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.NB.Corpus\n ( corpus\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.AmountOfMoney.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale NB Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple Dollar 10)\n [ \"$10\"\n , \"10$\"\n , \"ti dollar\"\n ]\n , examples (simple Cent 10)\n [ \"ti \u00c3\u00b8re\"\n ]\n , examples (simple Dollar 10000)\n [ \"$10.000\"\n , \"10K$\"\n , \"$10k\"\n ]\n , examples (simple USD 1.23)\n [ \"USD1,23\"\n ]\n , examples (simple NOK 10)\n [ \"10kroner\"\n , \"10kr\"\n , \"ti kroner\"\n , \"10 NOK\"\n , \"ti norske kroner\"\n ]\n , examples (simple SEK 10)\n [ \"10kronor\"\n , \"10 svenske kroner\"\n , \"10 svenske kr\"\n , \"10 svenske kronor\"\n , \"ti kronor\"\n ]\n , examples (simple DKK 10)\n [ \"10 danske kroner\"\n , \"ti danske kroner\"\n , \"ti danske kr\"\n ]\n , examples (simple AUD 10)\n [ \"10 australske dollar\"\n , \"10 australske dollars\"\n ]\n , examples (simple CAD 10)\n [ \"10 kanadiske dollar\"\n , \"10 kanadiske dollars\"\n , \"10 canadiske dollar\"\n , \"10 canadiske dollars\"\n ]\n , examples (simple CHF 10)\n [ \"10 sveitsiske franc\"\n , \"10 sveitsiske francs\"\n ]\n , examples (simple CNY 10)\n [ \"10 yuan\"\n , \"10 kinesiske yuan\"\n , \"10 kinesisk yuan\"\n , \"10 renminbi\"\n , \"10 kinesiske renminbi\"\n , \"10 kinesisk renminbi\"\n ]\n , examples (simple CZK 10)\n [ \"10 koruna\"\n , \"10 tsjekkiske koruna\"\n ]\n , examples (simple INR 10)\n [ \"10 rupi\"\n , \"10 rupier\"\n , \"10 rupee\"\n , \"10 rupees\"\n , \"10 indisk rupi\"\n , \"10 indiske rupi\"\n , \"10 indiske rupee\"\n , \"10 indiske rupees\"\n , \"10 indiske rupier\"\n , \"10 indisk rupier\"\n , \"ti rupi\"\n , \"ti rupier\"\n , \"ti indisk rupi\"\n , \"ti indiske rupi\"\n , \"ti indiske rupee\"\n , \"ti indiske rupees\"\n , \"ti indiske rupier\"\n , \"ti indisk rupier\"\n ]\n , examples (simple JPY 10)\n [ \"10 japanske yen\"\n , \"10 yen\"\n , \"ti japanske yen\"\n , \"ti yen\"\n ]\n , examples (simple PKR 10)\n [ \"10 pakistansk rupi\"\n , \"10 pakistanske rupi\"\n , \"10 pakistanske rupee\"\n , \"10 pakistanske rupees\"\n , \"10 pakistanske rupier\"\n , \"10 pakistansk rupier\"\n , \"ti pakistansk rupi\"\n , \"ti pakistanske rupi\"\n , \"ti pakistanske rupee\"\n , \"ti pakistanske rupees\"\n , \"ti pakistanske rupier\"\n , \"ti pakistansk rupier\"\n ]\n , examples (simple PLN 10)\n [ \"10 zloty\"\n , \"10 sloty\"\n , \"10 polske zloty\"\n , \"10 polske sloty\"\n , \"ti zloty\"\n , \"ti sloty\"\n , \"ti polske zloty\"\n , \"ti polske sloty\"\n ]\n , examples (simple SGD 10)\n [ \"10 singapore dollar\"\n , \"10 singapore dollars\"\n , \"10 singaporske dollar\"\n , \"10 singaporske dollars\"\n , \"ti singapore dollar\"\n , \"ti singapore dollars\"\n , \"ti singaporske dollar\"\n , \"ti singaporske dollars\"\n ]\n , examples (simple THB 10)\n [ \"10 bhat\"\n , \"10 thai baht\"\n , \"10 thai bhat\"\n , \"10 thailand baht\"\n , \"10 thailand bhat\"\n , \"10 thailandske baht\"\n , \"10 thailandske bhat\"\n , \"ti baht\"\n , \"ti bhat\"\n , \"ti thai baht\"\n , \"ti thai bhat\"\n , \"ti thailand baht\"\n , \"ti thailand bhat\"\n , \"ti thailandske baht\"\n , \"ti thailandske bhat\"\n ]\n , examples (simple ZAR 10)\n [ \"10 rand\"\n , \"10 s\u00c3\u00b8rafrikanske rand\"\n , \"10 s\u00c3\u00b8r-afrikanske rand\"\n , \"10 rand\"\n , \"10 s\u00c3\u00b8rafrikanske rand\"\n , \"10 s\u00c3\u00b8r-afrikanske rand\"\n , \"ti rand\"\n , \"ti s\u00c3\u00b8rafrikanske rand\"\n , \"ti s\u00c3\u00b8r-afrikanske rand\"\n ]\n , examples (simple NOK 2.23)\n [ \"2 kroner og 23 \u00c3\u00b8re\"\n , \"to kroner 23 \u00c3\u00b8re\"\n , \"to kroner og 23 \u00c3\u00b8re\"\n , \"to kr 23\"\n ]\n , examples (simple SEK 2.23)\n [ \"2 kronor og 23 \u00c3\u00b6re\"\n , \"to kronor 23 \u00c3\u00b6re\"\n , \"to svenske kronor 23 \u00c3\u00b6re\"\n , \"to svenske kroner 23 \u00c3\u00b6re\"\n , \"to svenske kroner 23 \u00c3\u00b8re\"\n , \"to kronor og 23 \u00c3\u00b6re\"\n , \"to svenske kronor og 23 \u00c3\u00b6re\"\n , \"to svenske kroner og 23 \u00c3\u00b6re\"\n , \"to svenske kroner og 23 \u00c3\u00b8re\"\n , \"to svensk kroner og 23 \u00c3\u00b8re\"\n ]\n , examples (simple DKK 2.23)\n [ \"2 danske kroner og 23 \u00c3\u00b8re\"\n , \"to danske kroner 23 \u00c3\u00b8re\"\n , \"to danske kroner og 23 \u00c3\u00b8re\"\n , \"to danske kr 23\"\n , \"to dansk kr 23\"\n ]\n , examples (simple USD 2.23)\n [ \"2 amerikanske dollar og 23 cent\"\n , \"2 amerikanske dollars og 23 cent\"\n , \"2 amerikanske dollar og 23 cents\"\n , \"2 amerikanske dollars og 23 cents\"\n , \"to amerikanske dollar 23 cent\"\n , \"to amerikanske dollars 23 cent\"\n , \"to amerikanske dollar 23 cents\"\n , \"to amerikanske dollars 23 cents\"\n , \"to amerikanske dollar og 23 cent\"\n , \"to amerikanske dollars og 23 cent\"\n , \"to amerikanske dollar og 23 cents\"\n , \"to amerikanske dollars og 23 cents\"\n , \"to amerikanske dollar 23\"\n , \"to amerikanske dollars 23\"\n ]\n , examples (simple AUD 2.23)\n [ \"2 australske dollar og 23 cent\"\n , \"2 australske dollars og 23 cent\"\n , \"2 australske dollar og 23 cents\"\n , \"2 australske dollars og 23 cents\"\n , \"to australske dollar 23 cent\"\n , \"to australske dollars 23 cent\"\n , \"to australske dollar 23 cents\"\n , \"to australske dollars 23 cents\"\n , \"to australske dollar og 23 cent\"\n , \"to australske dollars og 23 cent\"\n , \"to australske dollar og 23 cents\"\n , \"to australske dollars og 23 cents\"\n , \"to australske dollar 23\"\n , \"to australske dollars 23\"\n ]\n , examples (simple CAD 2.23)\n [ \"2 kanadiske dollar og 23 cent\"\n , \"2 kanadiske dollars og 23 cent\"\n , \"2 canadiske dollar og 23 cent\"\n , \"2 canadiske dollars og 23 cent\"\n , \"2 kanadiske dollar og 23 cents\"\n , \"2 kanadiske dollars og 23 cents\"\n , \"2 canadiske dollar og 23 cents\"\n , \"2 canadiske dollars og 23 cents\"\n , \"to kanadiske dollar 23 cent\"\n , \"to kanadiske dollars 23 cent\"\n , \"to canadiske dollar 23 cent\"\n , \"to canadiske dollars 23 cent\"\n , \"to kanadiske dollar 23 cents\"\n , \"to kanadiske dollars 23 cents\"\n , \"to canadiske dollar 23 cents\"\n , \"to canadiske dollars 23 cents\"\n , \"to kanadiske dollar og 23 cent\"\n , \"to kanadiske dollars og 23 cent\"\n , \"to canadiske dollar og 23 cent\"\n , \"to canadiske dollars og 23 cent\"\n , \"to kanadiske dollar og 23 cents\"\n , \"to kanadiske dollars og 23 cents\"\n , \"to canadiske dollar og 23 cents\"\n , \"to canadiske dollars og 23 cents\"\n , \"to kanadiske dollar 23\"\n , \"to kanadiske dollars 23\"\n , \"to canadiske dollar 23\"\n , \"to canadiske dollars 23\"\n ]\n , examples (simple CHF 2.23)\n [ \"2 sveitsiske franc og 23 rappen\"\n , \"2 sveitsiske francs og 23 rappen\"\n , \"2 sveitsiske franc og 23 rp\"\n , \"2 sveitsiske francs og 23 rp\"\n , \"2 sveitsiske franc og 23 centime\"\n , \"2 sveitsiske francs og 23 centime\"\n , \"2 sveitsiske franc og 23 c\"\n , \"2 sveitsiske francs og 23 c\"\n , \"2 sveitsiske franc og 23 centesimo\"\n , \"2 sveitsiske francs og 23 centesimo\"\n , \"2 sveitsiske franc og 23 ct\"\n , \"2 sveitsiske francs og 23 ct\"\n , \"2 sveitsiske franc og 23 rap\"\n , \"2 sveitsiske francs og 23 rap\"\n , \"to sveitsiske franc 23 rappen\"\n , \"to sveitsiske francs 23 rappen\"\n , \"to sveitsiske franc 23 rp\"\n , \"to sveitsiske francs 23 rp\"\n , \"to sveitsiske franc 23 centime\"\n , \"to sveitsiske francs 23 centime\"\n , \"to sveitsiske franc 23 c\"\n , \"to sveitsiske francs 23 c\"\n , \"to sveitsiske franc 23 centesimo\"\n , \"to sveitsiske francs 23 centesimo\"\n , \"to sveitsiske franc 23 ct\"\n , \"to sveitsiske francs 23 ct\"\n , \"to sveitsiske franc 23 rap\"\n , \"to sveitsiske francs 23 rap\"\n , \"to sveitsiske franc og 23 rappen\"\n , \"to sveitsiske francs og 23 rappen\"\n , \"to sveitsiske franc og 23 rp\"\n , \"to sveitsiske francs og 23 rp\"\n , \"to sveitsiske franc og 23 centime\"\n , \"to sveitsiske francs og 23 centime\"\n , \"to sveitsiske franc og 23 c\"\n , \"to sveitsiske francs og 23 c\"\n , \"to sveitsiske franc og 23 centesimo\"\n , \"to sveitsiske francs og 23 centesimo\"\n , \"to sveitsiske franc og 23 ct\"\n , \"to sveitsiske francs og 23 ct\"\n , \"to sveitsiske franc og 23 rap\"\n , \"to sveitsiske francs og 23 rap\"\n , \"to sveitsiske franc 23\"\n , \"to sveitsiske francs 23\"\n ]\n , examples (simple CNY 2.23)\n [ \"2 yuan og 23 fen\"\n , \"2 kinesiske yuan og 23 fen\"\n , \"2 renminbi og 23 fen\"\n , \"2 kinesiske renminbi og 23 fen\"\n , \"to yuan 23 fen\"\n , \"to kinesiske yuan 23 fen\"\n , \"to renminbi 23 fen\"\n , \"to kinesiske renminbi 23 fen\"\n , \"to yuan og 23 fen\"\n , \"to kinesiske yuan og 23 fen\"\n , \"to renminbi og 23 fen\"\n , \"to kinesiske renminbi og 23 fen\"\n , \"to yuan 23\"\n , \"to kinesiske yuan 23\"\n , \"to renminbi 23\"\n , \"to kinesiske renminbi 23\"\n ]\n , examples (simple CZK 2.23)\n [ \"2 koruna og 23 haleru\"\n , \"2 tsjekkiske koruna og 23 haleru\"\n , \"to koruna 23 haleru\"\n , \"to tsjekkiske koruna 23 haleru\"\n , \"to koruna og 23 haleru\"\n , \"to tsjekkiske koruna og 23 haleru\"\n , \"to koruna 23\"\n , \"to tsjekkiske koruna 23\"\n ]\n , examples (simple HKD 2.23)\n [ \"2 hong kong dollar og 23 cent\"\n , \"2 hong kong dollar og 23 cents\"\n , \"2 hong kong dollars og 23 cent\"\n , \"2 hong kong dollars og 23 cents\"\n , \"2 hong kong dollar og 23 cents\"\n , \"2 hong kong dollars og 23 cents\"\n , \"to hong kong dollar 23 cent\"\n , \"to hong kong dollars 23 cent\"\n , \"to hong kong dollar 23 cents\"\n , \"to hong kong dollars 23 cents\"\n , \"to hong kong dollar og 23 cent\"\n , \"to hong kong dollars og 23 cent\"\n , \"to hong kong dollar og 23 cents\"\n , \"to hong kong dollars og 23 cents\"\n , \"to hong kong dollar 23\"\n , \"to hong kong dollars 23\"\n ]\n , examples (simple INR 2.23)\n [ \"2 indiske rupi og 23 paise\"\n , \"2 indiske rupier og 23 paise\"\n , \"to indiske rupi 23 paise\"\n , \"to indiske rupier 23 paise\"\n , \"to indiske rupier 23 paise\"\n , \"to indiske rupi og 23 paise\"\n , \"to indiske rupier og 23 paise\"\n , \"to indiske rupi 23\"\n , \"to indiske rupier 23\"\n ]\n , examples (simple NZD 2.23)\n [ \"2 new zealand dollar og 23 cent\"\n , \"2 new zealand dollars og 23 cent\"\n , \"2 new zealand dollars og 23 cents\"\n , \"2 new zealandske dollar og 23 cent\"\n , \"2 new zealandske dollars og 23 cent\"\n , \"2 new zealandske dollars og 23 cents\"\n , \"2 new zealand dollar og 23 cents\"\n , \"2 new zealand dollars og 23 cents\"\n , \"2 nz dollar og 23 cents\"\n , \"2 nz dollars og 23 cents\"\n , \"to new zealand dollar 23 cent\"\n , \"to new zealand dollars 23 cent\"\n , \"to new zealand dollars 23 cents\"\n , \"to new zealandske dollar 23 cent\"\n , \"to new zealandske dollars 23 cent\"\n , \"to new zealandske dollars 23 cents\"\n , \"to new zealand dollar 23 cents\"\n , \"to new zealand dollars 23 cents\"\n , \"to new zealand dollars 23 cent\"\n , \"to new zealand dollar og 23 cent\"\n , \"to new zealand dollars og 23 cent\"\n , \"to new zealandske dollar og 23 cent\"\n , \"to new zealandske dollars og 23 cent\"\n , \"to new zealandske dollars og 23 cents\"\n , \"to new zealand dollar og 23 cents\"\n , \"to new zealand dollars og 23 cent\"\n , \"to new zealand dollars og 23 cents\"\n , \"to new zealand dollar 23\"\n , \"to new zealand dollars 23\"\n , \"to new zealandske dollar 23\"\n , \"to new zealandske dollars 23\"\n , \"to nz dollar 23\"\n , \"to nz dollars 23\"\n ]\n , examples (simple PLN 2.23)\n [ \"2 zloty og 23 groszy\"\n , \"2 sloty og 23 groszy\"\n , \"2 polske zloty og 23 groszy\"\n , \"2 polske sloty og 23 groszy\"\n , \"to zloty 23 groszy\"\n , \"to sloty 23 groszy\"\n , \"to polske zloty 23 groszy\"\n , \"to polske sloty 23 groszy\"\n , \"to zloty og 23 groszy\"\n , \"to sloty og 23 groszy\"\n , \"to polske zloty og 23 groszy\"\n , \"to polske sloty og 23 groszy\"\n , \"to zloty 23\"\n , \"to sloty 23\"\n , \"to polske zloty 23\"\n , \"to polske sloty 23\"\n ]\n , examples (simple SGD 2.23)\n [ \"2 singapore dollar og 23 cent\"\n , \"2 singapore dollars og 23 cent\"\n , \"2 singaporske dollar og 23 cent\"\n , \"2 singaporske dollars og 23 cent\"\n , \"2 singapore dollar og 23 cents\"\n , \"2 singapore dollars og 23 cents\"\n , \"to singapore dollar 23 cent\"\n , \"to singapore dollars 23 cent\"\n , \"to singaporske dollar 23 cent\"\n , \"to singaporske dollars 23 cent\"\n , \"to singapore dollar 23 cents\"\n , \"to singapore dollars 23 cents\"\n , \"to singapore dollar og 23 cent\"\n , \"to singapore dollars og 23 cent\"\n , \"to singaporske dollar og 23 cent\"\n , \"to singaporske dollars og 23 cent\"\n , \"to singapore dollar og 23 cents\"\n , \"to singapore dollars og 23 cents\"\n , \"to singapore dollar 23\"\n , \"to singapore dollars 23\"\n , \"to singaporske dollar 23\"\n , \"to singaporske dollars 23\"\n ]\n , examples (simple ZAR 2.23)\n [ \"2 rand og 23 cent\"\n , \"2 s\u00c3\u00b8rafrikanske rand og 23 cent\"\n , \"2 s\u00c3\u00b8rafrikanske rand og 23 cents\"\n , \"2 s\u00c3\u00b8r-afrikanske rand og 23 cent\"\n , \"2 s\u00c3\u00b8r-afrikanske rand og 23 cents\"\n , \"to rand 23 cent\"\n , \"to s\u00c3\u00b8rafrikanske rand 23 cent\"\n , \"to s\u00c3\u00b8rafrikanske rand 23 cents\"\n , \"to s\u00c3\u00b8r-afrikanske rand 23 cent\"\n , \"to s\u00c3\u00b8r-afrikanske rand 23 cents\"\n , \"to rand og 23 cent\"\n , \"to s\u00c3\u00b8rafrikanske rand og 23 cent\"\n , \"to s\u00c3\u00b8rafrikanske rand og 23 cents\"\n , \"to s\u00c3\u00b8r-afrikanske rand og 23 cent\"\n , \"to s\u00c3\u00b8r-afrikanske rand og 23 cents\"\n , \"to rand 23\"\n , \"to s\u00c3\u00b8rafrikanske rand 23\"\n , \"to s\u00c3\u00b8r-afrikanske rand 23\"\n ]\n , examples (simple THB 2.23)\n [ \"2 baht og 23 satang\"\n , \"2 bhat og 23 satang\"\n , \"2 thai baht og 23 satang\"\n , \"2 thai bhat og 23 satang\"\n , \"2 thailandske baht og 23 satang\"\n , \"2 thailandske bhat og 23 satang\"\n , \"to baht 23 satang\"\n , \"to bhat 23 satang\"\n , \"to thai baht 23 satang\"\n , \"to thai bhat 23 satang\"\n , \"to thailandske baht 23 satang\"\n , \"to thailandske bhat 23 satang\"\n , \"to baht og 23 satang\"\n , \"to bhat og 23 satang\"\n , \"to thai baht og 23 satang\"\n , \"to thai bhat og 23 satang\"\n , \"to thailandske baht og 23 satang\"\n , \"to thailandske bhat og 23 satang\"\n , \"to baht 23\"\n , \"to bhat 23\"\n , \"to thai baht 23\"\n , \"to thai bhat 23\"\n , \"to thailandske baht 23\"\n , \"to thailandske bhat 23\"\n ]\n , examples (simple Cent 10)\n [ \"ti cent\"\n , \"ti cents\"\n , \"ti pence\"\n , \"ti penny\"\n , \"ti pennies\"\n , \"10 cent\"\n , \"10 cents\"\n , \"10 cents\"\n , \"10 pence\"\n , \"10 penny\"\n , \"10 \u00c3\u00b8re\"\n , \"10 \u00c3\u00b8rer\"\n , \"10 \u00c3\u00b6re\"\n , \"10 \u00c3\u00b6rer\"\n , \"10 p\"\n , \"10 c\"\n , \"10 fen\"\n , \"10 haleru\"\n , \"10 groszy\"\n , \"10 paise\"\n , \"10 paisa\"\n , \"10 centesimo\"\n , \"10 centesimi\"\n , \"10 centime\"\n , \"10 centimes\"\n , \"10 ct\"\n , \"10 rap\"\n , \"10 rappen\"\n , \"10 rappens\"\n , \"10 rp\"\n , \"10 satang\"\n ]\n , examples (simple EUR 20)\n [ \"20\u00e2\u201a\u00ac\"\n , \"20 euro\"\n , \"20 Euro\"\n , \"20 Euros\"\n , \"EUR 20\"\n ]\n , examples (simple EUR 29.99)\n [ \"EUR29,99\"\n ]\n , examples (simple INR 20)\n [ \"Rs. 20\"\n , \"Rs 20\"\n , \"20 Rupees\"\n , \"20Rs\"\n , \"Rs20\"\n , \"INR20\"\n ]\n , examples (simple INR 20.43)\n [ \"20 Rupees 43\"\n , \"tjue rupees 43\"\n , \"tjue rupees 43\u00c2\u00a2\"\n ]\n , examples (simple Pound 9)\n [ \"\u00c2\u00a39\"\n , \"ni pund\"\n ]\n , examples (simple GBP 3.01)\n [ \"GBP3,01\"\n , \"GBP 3,01\"\n ]\n ]\n", "num_lines": 554} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.NB.Rules\n ( rules\n ) where\n\nimport Data.Maybe\nimport Data.String\nimport Prelude\n\nimport Duckling.AmountOfMoney.Helpers\nimport Duckling.AmountOfMoney.Types (Currency (..), AmountOfMoneyData (..))\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers (isNatural, isPositive)\nimport Duckling.Numeral.Types (NumeralData (..))\nimport Duckling.Types\nimport qualified Duckling.AmountOfMoney.Types as TAmountOfMoney\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleUnitAmount :: Rule\nruleUnitAmount = Rule\n { name = \" \"\n , pattern =\n [ Predicate isCurrencyOnly\n , Predicate isPositive\n ]\n , prod = \\case\n (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.currency = c}:\n Token Numeral NumeralData{TNumeral.value = v}:\n _) -> Just $ Token AmountOfMoney . withValue v $ currencyOnly c\n _ -> Nothing\n }\n\nruleIntersectAndNumeral :: Rule\nruleIntersectAndNumeral = Rule\n { name = \"intersect (and number)\"\n , pattern =\n [ Predicate isWithoutCents\n , regex \"og\"\n , Predicate isNatural\n ]\n , prod = \\case\n (Token AmountOfMoney fd:\n _:\n Token Numeral NumeralData{TNumeral.value = c}:\n _) -> Just $ Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nruleAboutAmountofmoney :: Rule\nruleAboutAmountofmoney = Rule\n { name = \"about \"\n , pattern =\n [ regex \"omtrent|cirka|rundt|ca\"\n , Predicate isMoneyWithValue\n ]\n , prod = \\case\n (_:token:_) -> Just token\n _ -> Nothing\n }\n\nruleCent :: Rule\nruleCent = Rule\n { name = \"cent\"\n , pattern =\n [ regex \"cent(?:\\\\b|s)|\\\\bc\\\\b|pen(?:ce|ny|nies)|\\\\bp\\\\b|(?:\u00c3\u00b8|\u00c3\u00b6)rer?|fen|haleru|groszy|pais(?:e|a)\\\n \\|centesim(?:o|i)|centimes?|\\\\bct?\\\\b|\\\\brp?\\\\b|rap(?:pen)?s?|satang\"\n ]\n , prod = const $ Just $ Token AmountOfMoney $ currencyOnly Cent\n }\n\nruleIntersectXCents :: Rule\nruleIntersectXCents = Rule\n { name = \"intersect (X cents)\"\n , pattern =\n [ Predicate isWithoutCents\n , Predicate isCents\n ]\n , prod = \\case\n (Token AmountOfMoney fd:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just c}:\n _) -> Just $ Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nruleNok :: Rule\nruleNok = Rule\n { name = \"NOK\"\n , pattern =\n [ regex \"(?:norske? ?)?kr(?:oner?)?\"\n ]\n , prod = const $ Just $ Token AmountOfMoney $ currencyOnly NOK\n }\n\nrulePound :: Rule\nrulePound = Rule\n { name = \"\u00c2\u00a3\"\n , pattern =\n [ regex \"po?und?s?\"\n ]\n , prod = const $ Just $ Token AmountOfMoney $ currencyOnly Pound\n }\n\nruleIntersectAndXCents :: Rule\nruleIntersectAndXCents = Rule\n { name = \"intersect (and X cents)\"\n , pattern =\n [ Predicate isWithoutCents\n , regex \"og\"\n , Predicate isCents\n ]\n , prod = \\case\n (Token AmountOfMoney fd:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just c}:\n _) -> Just $ Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nruleIntersect :: Rule\nruleIntersect = Rule\n { name = \"intersect\"\n , pattern =\n [ Predicate isWithoutCents\n , Predicate isNatural\n ]\n , prod = \\case\n (Token AmountOfMoney fd:\n Token Numeral NumeralData{TNumeral.value = c}:\n _) -> Just $ Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nruleDirham :: Rule\nruleDirham = Rule\n { name = \"AED\"\n , pattern =\n [ regex \"dirhams?\"\n ]\n , prod = const $ Just $ Token AmountOfMoney $ currencyOnly AED\n }\n\nruleSEK :: Rule\nruleSEK = Rule\n { name = \"SEK\"\n , pattern =\n [ regex \"(?:svenske? )?kron(?:a|or)|svenske? kr(?:oner?)?\"\n ]\n , prod = const $ Just $ Token AmountOfMoney $ currencyOnly SEK\n }\n\nruleGBP :: Rule\nruleGBP = Rule\n { name = \"GBP\"\n , pattern =\n [ regex \"(?:britiske?|engelske?) po?unds?\"\n ]\n , prod = const $ Just $ Token AmountOfMoney $ currencyOnly GBP\n }\n\nruleDKK :: Rule\nruleDKK = Rule\n { name = \"DKK\"\n , pattern =\n [ regex \"danske? kr(?:oner?)?\"\n ]\n , prod = const $ Just $ Token AmountOfMoney $ currencyOnly DKK\n }\n\nruleUSD :: Rule\nruleUSD = Rule\n { name = \"USD\"\n , pattern =\n [ regex \"amerikanske? dollars?\"\n ]\n , prod = const $ Just $ Token AmountOfMoney $ currencyOnly USD\n }\n\nruleAUD :: Rule\nruleAUD = Rule\n { name = \"AUD\"\n , pattern =\n [ regex \"australske? dollars?\"\n ]\n , prod = const $ Just $ Token AmountOfMoney $ currencyOnly AUD\n }\n\nruleCAD :: Rule\nruleCAD = Rule\n { name = \"CAD\"\n , pattern =\n [ regex \"(?:k|c)anadiske? dollars?\"\n ]\n , prod = const $ Just $ Token AmountOfMoney $ currencyOnly CAD\n }\n\nruleCHF :: Rule\nruleCHF = Rule\n { name = \"CHF\"\n , pattern =\n [ regex \"sveitsiske? francs?\"\n ]\n , prod = const $ Just $ Token AmountOfMoney $ currencyOnly CHF\n }\n\nruleCNY :: Rule\nruleCNY = Rule\n { name = \"CNY\"\n , pattern =\n [ regex \"(?:kinesiske? )?(?:yuan|renminbi)\"\n ]\n , prod = const $ Just $ Token AmountOfMoney $ currencyOnly CNY\n }\n\nruleCZK :: Rule\nruleCZK = Rule\n { name = \"CZK\"\n , pattern =\n [ regex \"(?:tsjekkiske? )?koruna\"\n ]\n , prod = const $ Just $ Token AmountOfMoney $ currencyOnly CZK\n }\n\nruleHKD :: Rule\nruleHKD = Rule\n { name = \"HKD\"\n , pattern =\n [ regex \"hong kong dollars?\"\n ]\n , prod = const $ Just $ Token AmountOfMoney $ currencyOnly HKD\n }\n\nruleINR :: Rule\nruleINR = Rule\n { name = \"INR\"\n , pattern =\n [ regex \"(?:indiske? )?rup(?:i(?:er)?|ees?)\"\n ]\n , prod = const $ Just $ Token AmountOfMoney $ currencyOnly INR\n }\n\nruleJPY :: Rule\nruleJPY = Rule\n { name = \"JPY\"\n , pattern =\n [ regex \"japanske? yen\"\n ]\n , prod = const $ Just $ Token AmountOfMoney $ currencyOnly JPY\n }\n\nruleNZD :: Rule\nruleNZD = Rule\n { name = \"NZD\"\n , pattern =\n [ regex \"(?:nz|new zealand(?:ske)?) dollars?\"\n ]\n , prod = const $ Just $ Token AmountOfMoney $ currencyOnly NZD\n }\n\nrulePKR :: Rule\nrulePKR = Rule\n { name = \"PKR\"\n , pattern =\n [ regex \"pakistanske? rup(?:i(?:er)?|ees?)\"\n ]\n , prod = const $ Just $ Token AmountOfMoney $ currencyOnly PKR\n }\n\nrulePLN :: Rule\nrulePLN = Rule\n { name = \"PLN\"\n , pattern =\n [ regex \"(?:polske? )?(?:z|s)?lotys?\"\n ]\n , prod = const $ Just $ Token AmountOfMoney $ currencyOnly PLN\n }\n\nruleSGD :: Rule\nruleSGD = Rule\n { name = \"SGD\"\n , pattern =\n [ regex \"singapor(?:e|ske?) dollars?\"\n ]\n , prod = const $ Just $ Token AmountOfMoney $ currencyOnly SGD\n }\n\nruleTHB :: Rule\nruleTHB = Rule\n { name = \"THB\"\n , pattern =\n [ regex \"(?:thai(?:land(?:ske?)?)? )?b(?:ah|ha)t\"\n ]\n , prod = const $ Just $ Token AmountOfMoney $ currencyOnly THB\n }\n\nruleZAR :: Rule\nruleZAR = Rule\n { name = \"ZAR\"\n , pattern =\n [ regex \"(?:s\u00c3\u00b8r(?: |-)?afrika(?:nske?)? )?rand\"\n ]\n , prod = const $ Just $ Token AmountOfMoney $ currencyOnly ZAR\n }\n\nrules :: [Rule]\nrules =\n [ ruleUnitAmount\n , ruleAboutAmountofmoney\n , ruleCent\n , ruleDirham\n , ruleIntersect\n , ruleIntersectAndNumeral\n , ruleIntersectAndXCents\n , ruleIntersectXCents\n , ruleNok\n , rulePound\n , ruleSEK\n , ruleDKK\n , ruleUSD\n , ruleAUD\n , ruleCAD\n , ruleGBP\n , ruleCHF\n , ruleCNY\n , ruleCZK\n , ruleHKD\n , ruleINR\n , ruleJPY\n , ruleNZD\n , rulePKR\n , rulePLN\n , ruleSGD\n , ruleTHB\n , ruleZAR\n ]\n", "num_lines": 345} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.NL.Corpus\n ( corpus\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.AmountOfMoney.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale NL Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple Dollar 1)\n [ \"$1\"\n , \"1 dollar\"\n ]\n , examples (simple Dollar 10)\n [ \"$10\"\n , \"$ 10\"\n , \"10$\"\n , \"10 dollars\"\n , \"tien dollar\"\n ]\n , examples (simple Cent 10)\n [ \"10 cent\"\n , \"tien pennies\"\n , \"tien cents\"\n , \"10 c\"\n , \"10\u00c2\u00a2\"\n ]\n , examples (simple Dollar 10000)\n [ \"$10K\"\n , \"10k$\"\n , \"$10000\"\n , \"$10.000\"\n , \"$10.000,00\"\n , \"10000,00 $\"\n ]\n , examples (simple USD 3.14)\n [ \"USD3,14\"\n , \"3,14US$\"\n , \"US$ 3,14\"\n ]\n , examples (simple EUR 20)\n [ \"20\\x20ac\"\n , \"20 euros\"\n , \"20 Euro\"\n , \"20 Euros\"\n , \"EUR 20\"\n , \"EUR 20,0\"\n , \"20\u00e2\u201a\u00ac\"\n , \"20 \u00e2\u201a\u00acur\"\n ]\n , examples (simple Dollar 20.43)\n [ \"$20 en 43c\"\n , \"$20,43\"\n , \"20 dollar 43c\"\n , \"20 dollars 43 cents\"\n , \"20 dollar 43\"\n ]\n , examples (simple GBP 3.01)\n [ \"GBP3,01\"\n , \"GBP 3,01\"\n , \"3 GBP een penny\"\n ]\n , examples (simple Unnamed 42)\n [ \"42 bucks\"\n , \"ongeveer twee-en-veertig bucks\"\n , \"precies 42 bucks\"\n ]\n , examples (between Dollar (10, 20))\n [ \"vanaf 10 dollars tot 20 dollars\"\n , \"rond de 10-20 dollars\"\n , \"tussen 10 dollars en 20 dollars\"\n , \"ongeveer $10-$20\"\n , \"10-20 dollars\"\n ]\n , examples (between Dollar (1.1, 1.3))\n [ \"tussen 1,1 dollar en 1,3 dollars\"\n , \"van 1,1$ en 1,3 dollars\"\n ]\n , examples (under EUR 7)\n [ \"minder dan 7 euros\"\n , \"minder dan zeven EUR\"\n , \"lager dan 7\u00e2\u201a\u00ac\"\n ]\n , examples (above Dollar 1.42)\n [ \"meer dan 1 dollar en 42 cents\"\n , \"minstens $1,42\"\n , \"boven de 1,42 dollars\"\n , \"boven de 1 dollar en 42 cents\"\n ]\n ]\n", "num_lines": 108} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.NL.Rules\n ( rules\n ) where\n\nimport Data.Maybe\nimport Data.String\nimport Prelude\nimport qualified Data.Text as Text\n\nimport Duckling.AmountOfMoney.Helpers\nimport Duckling.AmountOfMoney.Types (Currency(..), AmountOfMoneyData (..))\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers (isNatural, isPositive)\nimport Duckling.Numeral.Types (NumeralData (..))\nimport Duckling.Regex.Types\nimport Duckling.Types\nimport qualified Duckling.AmountOfMoney.Types as TAmountOfMoney\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleUnitAmount :: Rule\nruleUnitAmount = Rule\n { name = \" \"\n , pattern =\n [ Predicate isCurrencyOnly\n , Predicate isPositive\n ]\n , prod = \\case\n (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.currency = c}:\n Token Numeral NumeralData{TNumeral.value = v}:\n _) -> Just . Token AmountOfMoney . withValue v $ currencyOnly c\n _ -> Nothing\n }\n\nrulePounds :: Rule\nrulePounds = Rule\n { name = \"\u00c2\u00a3\"\n , pattern =\n [ regex \"pou?nds?\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly Pound\n }\n\nruleCent :: Rule\nruleCent = Rule\n { name = \"cent\"\n , pattern =\n [ regex \"cents?|penn(y|ies)|pence|sens?\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly Cent\n }\n\nruleBucks :: Rule\nruleBucks = Rule\n { name = \"bucks\"\n , pattern =\n [ regex \"bucks?\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly Unnamed\n }\n\nruleIntersectAndXCents :: Rule\nruleIntersectAndXCents = Rule\n { name = \"intersect (and X cents)\"\n , pattern =\n [ Predicate isWithoutCents\n , regex \"en\"\n , Predicate isCents\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just c}:\n _) -> Just . Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nruleIntersect :: Rule\nruleIntersect = Rule\n { name = \"intersect\"\n , pattern =\n [ Predicate isWithoutCents\n , Predicate isNatural\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n Token Numeral NumeralData{TNumeral.value = c}:\n _) -> Just . Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nruleIntersectAndNumeral :: Rule\nruleIntersectAndNumeral = Rule\n { name = \"intersect (and number)\"\n , pattern =\n [ Predicate isWithoutCents\n , regex \"en\"\n , Predicate isNatural\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n _:\n Token Numeral NumeralData{TNumeral.value = c}:\n _) -> Just . Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nruleIntersectXCents :: Rule\nruleIntersectXCents = Rule\n { name = \"intersect (X cents)\"\n , pattern =\n [ Predicate isWithoutCents\n , Predicate isCents\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just c}:\n _) -> Just . Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nrulePrecision :: Rule\nrulePrecision = Rule\n { name = \"about|exactly \"\n , pattern =\n [ regex \"precies|ongeveer|over|dicht|bijna|in de buurt|rond de\"\n , Predicate isMoneyWithValue\n ]\n , prod = \\tokens -> case tokens of\n (_:token:_) -> Just token\n _ -> Nothing\n }\n\nruleIntervalBetweenNumeral :: Rule\nruleIntervalBetweenNumeral = Rule\n { name = \"between|from to|and \"\n , pattern =\n [ regex \"tussen|vanaf|van\"\n , Predicate isPositive\n , regex \"tot|en\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\tokens -> case tokens of\n (_:\n Token Numeral NumeralData{TNumeral.value = from}:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c}:\n _) | from < to ->\n Just . Token AmountOfMoney . withInterval (from, to) $ currencyOnly c\n _ -> Nothing\n }\n\nruleIntervalBetween :: Rule\nruleIntervalBetween = Rule\n { name = \"between|from to|and \"\n , pattern =\n [ regex \"tussen|vanaf|van\"\n , Predicate isSimpleAmountOfMoney\n , regex \"tot|en\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\tokens -> case tokens of\n (_:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just from,\n TAmountOfMoney.currency = c1}:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c2}:\n _) | from < to && c1 == c2 ->\n Just . Token AmountOfMoney . withInterval (from, to) $ currencyOnly c1\n _ -> Nothing\n }\n\nruleIntervalNumeralDash :: Rule\nruleIntervalNumeralDash = Rule\n { name = \" - \"\n , pattern =\n [ Predicate isNatural\n , regex \"\\\\-\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = from}:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c}:\n _) | from < to ->\n Just . Token AmountOfMoney . withInterval (from, to) $ currencyOnly c\n _ -> Nothing\n }\n\nruleIntervalDash :: Rule\nruleIntervalDash = Rule\n { name = \" - \"\n , pattern =\n [ Predicate isSimpleAmountOfMoney\n , regex \"\\\\-\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just from,\n TAmountOfMoney.currency = c1}:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c2}:\n _) | from < to && c1 == c2 ->\n Just . Token AmountOfMoney . withInterval (from, to) $ currencyOnly c1\n _ -> Nothing\n }\n\nruleIntervalMax :: Rule\nruleIntervalMax = Rule\n { name = \"under/less/lower/no more than \"\n , pattern =\n [ regex \"(minder|lager|niet? meer) dan\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\tokens -> case tokens of\n (_:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c}:\n _) -> Just . Token AmountOfMoney . withMax to $ currencyOnly c\n _ -> Nothing\n }\n\nruleIntervalMin :: Rule\nruleIntervalMin = Rule\n { name = \"over/above/at least/more than \"\n , pattern =\n [ regex \"boven de|minstens|meer dan\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\tokens -> case tokens of\n (_:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c}:\n _) -> Just . Token AmountOfMoney . withMin to $ currencyOnly c\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleUnitAmount\n , ruleBucks\n , ruleCent\n , ruleIntersect\n , ruleIntersectAndNumeral\n , ruleIntersectAndXCents\n , ruleIntersectXCents\n , ruleIntervalBetweenNumeral\n , ruleIntervalBetween\n , ruleIntervalMax\n , ruleIntervalMin\n , ruleIntervalNumeralDash\n , ruleIntervalDash\n , rulePounds\n , rulePrecision\n ]\n", "num_lines": 270} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.PT.Corpus\n ( corpus\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.AmountOfMoney.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale PT Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple Dollar 10)\n [ \"$10\"\n , \"10$\"\n , \"dez dolares\"\n ]\n , examples (simple Dollar 10000)\n [ \"$10.000\"\n , \"10K$\"\n , \"$10k\"\n ]\n , examples (simple USD 1.23)\n [ \"USD1,23\"\n ]\n , examples (simple EUR 20)\n [ \"20\u00e2\u201a\u00ac\"\n , \"20 euros\"\n , \"20 Euro\"\n , \"20 Euros\"\n , \"EUR 20\"\n ]\n , examples (simple EUR 29.99)\n [ \"EUR29,99\"\n ]\n , examples (simple Pound 9)\n [ \"\u00c2\u00a39\"\n , \"nove libras\"\n ]\n , examples (simple GBP 3.01)\n [ \"GBP3,01\"\n , \"GBP 3,01\"\n ]\n , examples (simple PTS 15)\n [ \"15 Pt\"\n , \"15pta\"\n , \"15Ptas\"\n ]\n , examples (simple BRL 15)\n [ \"15 reais\"\n , \"15reais\"\n , \"15 Reais\"\n , \"BRL 15\"\n ]\n , examples (simple BRL 2.0)\n [ \"R$2,00\"\n , \"R$ 2,00\"\n , \"2,00 reais\"\n ]\n ]\n", "num_lines": 75} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.PT.Rules\n ( rules\n ) where\n\nimport Data.Maybe\nimport Data.String\nimport Prelude\n\nimport Duckling.AmountOfMoney.Helpers\nimport Duckling.AmountOfMoney.Types (Currency(..), AmountOfMoneyData (..))\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers (isNatural, isPositive)\nimport Duckling.Numeral.Types (NumeralData (..))\nimport Duckling.Types\nimport qualified Duckling.AmountOfMoney.Types as TAmountOfMoney\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleUnitAmount :: Rule\nruleUnitAmount = Rule\n { name = \" \"\n , pattern =\n [ Predicate isCurrencyOnly\n , Predicate isPositive\n ]\n , prod = \\case\n (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.currency = c}:\n Token Numeral NumeralData{TNumeral.value = v}:\n _) -> Just . Token AmountOfMoney . withValue v $ currencyOnly c\n _ -> Nothing\n }\n\nruleIntersectAndNumeral :: Rule\nruleIntersectAndNumeral = Rule\n { name = \"intersect (and number)\"\n , pattern =\n [ Predicate isWithoutCents\n , regex \"e\"\n , Predicate isNatural\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n _:\n Token Numeral NumeralData{TNumeral.value = c}:\n _) -> Just . Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nruleDollar :: Rule\nruleDollar = Rule\n { name = \"$\"\n , pattern =\n [ regex \"dolares?\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly Dollar\n }\n\nruleCent :: Rule\nruleCent = Rule\n { name = \"cent\"\n , pattern =\n [ regex \"centavos?\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly Cent\n }\n\nruleIntersectXCents :: Rule\nruleIntersectXCents = Rule\n { name = \"intersect (X cents)\"\n , pattern =\n [ Predicate isWithoutCents\n , Predicate isCents\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just c}:\n _) -> Just . Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nrulePounds :: Rule\nrulePounds = Rule\n { name = \"\u00c2\u00a3\"\n , pattern =\n [ regex \"libras?\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly Pound\n }\n\nruleIntersectAndXCents :: Rule\nruleIntersectAndXCents = Rule\n { name = \"intersect (and X cents)\"\n , pattern =\n [ Predicate isWithoutCents\n , regex \"e\"\n , Predicate isCents\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just c}:\n _) -> Just . Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nruleIntersect :: Rule\nruleIntersect = Rule\n { name = \"intersect\"\n , pattern =\n [ Predicate isWithoutCents\n , Predicate isNatural\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n Token Numeral NumeralData{TNumeral.value = c}:\n _) -> Just . Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nruleBrl :: Rule\nruleBrl = Rule\n { name = \"BRL\"\n , pattern =\n [ regex \"reais|r\\\\$\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly BRL\n }\n\nrules :: [Rule]\nrules =\n [ ruleUnitAmount\n , ruleBrl\n , ruleCent\n , ruleDollar\n , ruleIntersect\n , ruleIntersectAndNumeral\n , ruleIntersectAndXCents\n , ruleIntersectXCents\n , rulePounds\n ]\n", "num_lines": 151} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.RO.Corpus\n ( corpus\n , negativeCorpus\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.AmountOfMoney.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncontext :: Context\ncontext = testContext {locale = makeLocale RO Nothing}\n\nnegativeCorpus :: NegativeCorpus\nnegativeCorpus = (context, testOptions, examples)\n where\n examples =\n [ \"10 de dolari\"\n ]\n\ncorpus :: Corpus\ncorpus = (context, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple RON 10)\n [ \"10 lei\"\n , \"10 roni\"\n , \"10 RON\"\n ]\n , examples (simple Cent 50)\n [ \"50 de bani\"\n , \"50 DE BANI\"\n ]\n , examples (simple RON 10.5)\n [ \"10,5 lei\"\n , \"10,5 ron\"\n , \"10 lei si 50 bani\"\n ]\n , examples (simple Dollar 10)\n [ \"$10\"\n , \"10$\"\n , \"zece dolari\"\n , \"10 dolari\"\n ]\n , examples (simple Cent 10)\n [ \"zece centi\"\n , \"zece cen\u00c8\u203ai\"\n ]\n , examples (simple Dollar 10000)\n [ \"$10.000\"\n , \"$10000\"\n ]\n , examples (simple USD 1.23)\n [ \"USD1,23\"\n ]\n , examples (simple Dollar 1)\n [ \"1 dolar\"\n , \"un dolar\"\n , \"$1\"\n ]\n , examples (simple Cent 2)\n [ \"2 centi\"\n ]\n , examples (simple Cent 23)\n [ \"23 de centi\"\n ]\n , examples (simple Dollar 2.23)\n [ \"2 dolari si 23 de centi\"\n , \"2 dolari \u00c8\u2122i 23 de cen\u00c8\u203ai\"\n , \"doi dolari si dou\u00c4\u0192zeci si trei de centi\"\n , \"doi dolari \u00c8\u2122i dou\u00c4\u0192zeci \u00c8\u2122i trei de cen\u00c8\u203ai\"\n , \"2 dolari 23 de centi\"\n , \"doi dolari si 23\"\n , \"doi dolari \u00c8\u2122i 23\"\n ]\n , examples (simple EUR 20)\n [ \"20\u00e2\u201a\u00ac\"\n , \"20 de euro\"\n , \"20 de Euro\"\n , \"EUR 20\"\n ]\n , examples (simple EUR 29.99)\n [ \"EUR29,99\"\n ]\n , examples (simple Pound 9)\n [ \"\u00c2\u00a39\"\n , \"noua lir\"\n , \"nou\u00c4\u0192 lire\"\n ]\n , examples (simple GBP 3.01)\n [ \"GBP3,01\"\n , \"GBP 3,01\"\n ]\n , examples (simple QAR 1)\n [ \"un rial qatarian\"\n , \"1 rial qataria\"\n ]\n , examples (simple EGP 10)\n [ \"zece lira egiptiana\"\n ]\n , examples (simple LBP 1)\n [ \"una lir\u00c4\u0192 libanez\u00c4\u0192\"\n ]\n , examples (simple INR 42)\n [ \"42 de rupii\"\n , \"Rs. 42\"\n ]\n , examples (simple KWD 1)\n [ \"un dinar kuweitian\"\n ]\n , examples (simple AED 2)\n [ \"2 dirhami\"\n ]\n , examples (simple SAR 1)\n [ \"1 rial saudit\"\n , \"un rial saudi\"\n ]\n , examples (between RON (5, 15))\n [ \"intre 5 si 15 lei\"\n , \"intre 5 \u00c8\u2122i 15 lei\"\n , \"de la 5 RON la 15 RON\"\n , \"intre 5 lei si 15 lei\"\n , \"de la 5 la 15 lei\"\n , \"5 - 15 roni\"\n , \"aproximativ 5-15 lei\"\n , \"aproape de 5-15 lei\"\n , \"cam 5-15 RON\"\n ]\n , examples (under EUR 7)\n [ \"sub \u00c8\u2122apte euro\"\n , \"mai putin de 7 EUR\"\n , \"mai pu\u00c8\u203ain de 7 EUR\"\n , \"nu chiar 7\u00e2\u201a\u00ac\"\n , \"nici macar 7 euro\"\n , \"mai ieftin de 7\u00e2\u201a\u00ac\"\n , \"cel mult 7 euro\"\n ]\n , examples (above Dollar 3)\n [ \"mai mult de 3 dolari\"\n , \"peste 3 dolari\"\n , \"mai scump de trei dolari\"\n ]\n ]\n", "num_lines": 157} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.RO.Rules\n ( rules\n ) where\n\nimport Data.Maybe\nimport Data.String\nimport Prelude\nimport qualified Data.Text as Text\n\nimport Duckling.AmountOfMoney.Helpers\nimport Duckling.AmountOfMoney.Types (Currency(..), AmountOfMoneyData (..))\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers (isNatural, isPositive, numberWith)\nimport Duckling.Numeral.Types (NumeralData (..))\nimport Duckling.Regex.Types\nimport Duckling.Types\nimport qualified Duckling.AmountOfMoney.Types as TAmountOfMoney\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleUnitAmount :: Rule\nruleUnitAmount = Rule\n { name = \" \"\n , pattern =\n [ Predicate isCurrencyOnly\n , Predicate isPositive\n ]\n , prod = \\case\n (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.currency = c}:\n Token Numeral NumeralData{TNumeral.value = v}:\n _) -> Just . Token AmountOfMoney . withValue v $ currencyOnly c\n _ -> Nothing\n }\n\nruleAmountDeUnit :: Rule\nruleAmountDeUnit = Rule\n { name = \"= 20> de \"\n , pattern =\n [ numberWith TNumeral.value (>= 20)\n , regex \"de\"\n , Predicate isCurrencyOnly\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = v}:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.currency = c}:\n _) -> Just . Token AmountOfMoney . withValue v $ currencyOnly c\n _ -> Nothing\n }\n\nruleIntersectAndNumeral :: Rule\nruleIntersectAndNumeral = Rule\n { name = \"intersect (and number)\"\n , pattern =\n [ Predicate isWithoutCents\n , regex \"(s|\u00c8\u2122)i\"\n , Predicate isNatural\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n _:\n Token Numeral NumeralData{TNumeral.value = c}:\n _) -> Just . Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nruleRiyals :: Rule\nruleRiyals = Rule\n { name = \"riyals\"\n , pattern =\n [ regex \"rial (saudit?|qatarian?)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of\n \"saudi\" -> Just . Token AmountOfMoney $ currencyOnly SAR\n \"saudit\" -> Just . Token AmountOfMoney $ currencyOnly SAR\n \"qataria\" -> Just . Token AmountOfMoney $ currencyOnly QAR\n \"qatarian\" -> Just . Token AmountOfMoney $ currencyOnly QAR\n _ -> Nothing\n _ -> Nothing\n }\n\nruleDollar :: Rule\nruleDollar = Rule\n { name = \"$\"\n , pattern =\n [ regex \"dolari?\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly Dollar\n }\n\nrulePrecisionAmountOfMoney :: Rule\nrulePrecisionAmountOfMoney = Rule\n { name = \"about/exactly \"\n , pattern =\n [ regex \"exact|cam|aprox(\\\\.|imativ)?|(aproape|(i|\u00c3\u00ae)n jur)( de)?\"\n , Predicate isMoneyWithValue\n ]\n , prod = \\tokens -> case tokens of\n (_:token:_) -> Just token\n _ -> Nothing\n }\n\nruleCent :: Rule\nruleCent = Rule\n { name = \"cent|bani\"\n , pattern =\n [ regex \"bani?|cen(t|\u00c8\u203a)i?|c|\u00c2\u00a2\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly Cent\n }\n\nruleRon :: Rule\nruleRon = Rule\n { name = \"RON\"\n , pattern =\n [ regex \"roni|lei\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly RON\n }\n\nruleIntersectAndXCents :: Rule\nruleIntersectAndXCents = Rule\n { name = \"intersect (and X cents)\"\n , pattern =\n [ Predicate isWithoutCents\n , regex \"(s|\u00c8\u2122)i\"\n , Predicate isCents\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just c}:\n _) -> Just . Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nruleIntersectXCents :: Rule\nruleIntersectXCents = Rule\n { name = \"intersect (X cents)\"\n , pattern =\n [ Predicate isWithoutCents\n , Predicate isCents\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just c}:\n _) -> Just . Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nrulePounds :: Rule\nrulePounds = Rule\n { name = \"\u00c2\u00a3\"\n , pattern =\n [ regex \"lire?\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly Pound\n }\n\nruleOtherPounds :: Rule\nruleOtherPounds = Rule\n { name = \"other pounds\"\n , pattern =\n [ regex \"lir(a|\u00c4\u0192) (egiptian|libanez)(a|\u00c4\u0192)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (_:match:_)):_) -> case Text.toLower match of\n \"egiptian\" -> Just . Token AmountOfMoney $ currencyOnly EGP\n \"libanez\" -> Just . Token AmountOfMoney $ currencyOnly LBP\n _ -> Nothing\n _ -> Nothing\n }\n\nruleIntersect :: Rule\nruleIntersect = Rule\n { name = \"intersect\"\n , pattern =\n [ Predicate isWithoutCents\n , Predicate isNatural\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n Token Numeral NumeralData{TNumeral.value = c}:\n _) -> Just . Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nruleInr :: Rule\nruleInr = Rule\n { name = \"INR\"\n , pattern =\n [ regex \"rupii?\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly INR\n }\n\nruleKwd :: Rule\nruleKwd = Rule\n { name = \"KWD\"\n , pattern =\n [ regex \"dinar kuweitian\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly KWD\n }\n\nruleAed :: Rule\nruleAed = Rule\n { name = \"AED\"\n , pattern =\n [ regex \"dirhami?\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly AED\n }\n\nruleIntervalBetweenNumeral :: Rule\nruleIntervalBetweenNumeral = Rule\n { name = \"between|from to|and \"\n , pattern =\n [ regex \"intre|de la\"\n , Predicate isPositive\n , regex \"[s\u00c8\u2122]i|la\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\tokens -> case tokens of\n (_:\n Token Numeral NumeralData{TNumeral.value = from}:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c}:\n _) | from < to ->\n Just . Token AmountOfMoney . withInterval (from, to) $ currencyOnly c\n _ -> Nothing\n }\n\nruleIntervalBetween :: Rule\nruleIntervalBetween = Rule\n { name = \"between|from to|and \"\n , pattern =\n [ regex \"intre|de la\"\n , Predicate isSimpleAmountOfMoney\n , regex \"[s\u00c8\u2122]i|la\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\tokens -> case tokens of\n (_:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just from,\n TAmountOfMoney.currency = c1}:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c2}:\n _) | from < to && c1 == c2 ->\n Just . Token AmountOfMoney . withInterval (from, to) $ currencyOnly c1\n _ -> Nothing\n }\n\nruleIntervalNumeralDash :: Rule\nruleIntervalNumeralDash = Rule\n { name = \" - \"\n , pattern =\n [ Predicate isNatural\n , regex \"-\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = from}:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c}:\n _) | from < to ->\n Just . Token AmountOfMoney . withInterval (from, to) $ currencyOnly c\n _ -> Nothing\n }\n\nruleIntervalDash :: Rule\nruleIntervalDash = Rule\n { name = \" - \"\n , pattern =\n [ Predicate isSimpleAmountOfMoney\n , regex \"-\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just from,\n TAmountOfMoney.currency = c1}:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c2}:\n _) | from < to && c1 == c2 ->\n Just . Token AmountOfMoney . withInterval (from, to) $ currencyOnly c1\n _ -> Nothing\n }\n\nruleIntervalMax :: Rule\nruleIntervalMax = Rule\n { name = \"under/less/lower/no more than \"\n , pattern =\n [ regex \"sub|mai (pu[t\u00c8\u203a]|ieft)in de|nu chiar|nici macar|cel mult\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\tokens -> case tokens of\n (_:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c}:\n _) -> Just . Token AmountOfMoney . withMax to $ currencyOnly c\n _ -> Nothing\n }\n\nruleIntervalMin :: Rule\nruleIntervalMin = Rule\n { name = \"over/above/at least/more than \"\n , pattern =\n [ regex \"peste|mai (mult|scump) de|cel pu[t\u00c8\u203a]in\"\n , Predicate isSimpleAmountOfMoney\n ]\n , prod = \\tokens -> case tokens of\n (_:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just to,\n TAmountOfMoney.currency = c}:\n _) -> Just . Token AmountOfMoney . withMin to $ currencyOnly c\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleUnitAmount\n , ruleAmountDeUnit\n , ruleAed\n , ruleCent\n , ruleDollar\n , ruleInr\n , ruleIntersect\n , ruleIntersectAndNumeral\n , ruleIntersectAndXCents\n , ruleIntersectXCents\n , ruleKwd\n , ruleOtherPounds\n , rulePounds\n , rulePrecisionAmountOfMoney\n , ruleRiyals\n , ruleRon\n , ruleIntervalBetween\n , ruleIntervalBetweenNumeral\n , ruleIntervalDash\n , ruleIntervalMax\n , ruleIntervalMin\n , ruleIntervalNumeralDash\n ]\n", "num_lines": 359} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.SV.Corpus\n ( corpus\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.AmountOfMoney.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale SV Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple Dollar 10)\n [ \"$10\"\n , \"10$\"\n , \"tio dollar\"\n ]\n , examples (simple Cent 10)\n [ \"tio \u00c3\u00b6re\"\n ]\n , examples (simple Dollar 10000)\n [ \"$10.000\"\n , \"10K$\"\n , \"$10k\"\n ]\n , examples (simple USD 1.23)\n [ \"USD1,23\"\n ]\n , examples (simple SEK 10)\n [ \"10kronor\"\n , \"10kr\"\n , \"10 kr\"\n , \"tio kronor\"\n , \"10 SEK\"\n ]\n , examples (simple SEK 2.23)\n [ \"2 kronor och 23 \u00c3\u00b6re\"\n , \"tv\u00c3\u00a5 kronor 23 \u00c3\u00b6re\"\n , \"tv\u00c3\u00a5 kronor och 23 \u00c3\u00b6re\"\n ]\n , examples (simple EUR 20)\n [ \"20\u00e2\u201a\u00ac\"\n , \"20 euro\"\n , \"20 Euro\"\n , \"20 Euros\"\n , \"EUR 20\"\n ]\n , examples (simple EUR 29.99)\n [ \"EUR29,99\"\n ]\n , examples (simple INR 20)\n [ \"Rs. 20\"\n , \"Rs 20\"\n , \"20 Rupees\"\n , \"20Rs\"\n , \"Rs20\"\n ]\n , examples (simple INR 20.43)\n [ \"20 Rupees 43\"\n , \"tjugo rupees 43\"\n ]\n , examples (simple INR 33)\n [ \"INR33\"\n ]\n , examples (simple Pound 9)\n [ \"\u00c2\u00a39\"\n , \"nio pund\"\n ]\n , examples (simple GBP 3.01)\n [ \"GBP3,01\"\n , \"GBP 3,01\"\n ]\n , examples (simple NOK 10)\n [ \"10 norska kronor\"\n , \"10 nkr\"\n ]\n ]\n", "num_lines": 92} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.SV.Rules\n ( rules\n ) where\n\nimport Data.Maybe\nimport Data.String\nimport Prelude\n\nimport Duckling.AmountOfMoney.Helpers\nimport Duckling.AmountOfMoney.Types (Currency(..), AmountOfMoneyData (..))\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers (isNatural, isPositive)\nimport Duckling.Numeral.Types (NumeralData (..))\nimport Duckling.Types\nimport qualified Duckling.AmountOfMoney.Types as TAmountOfMoney\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleUnitAmount :: Rule\nruleUnitAmount = Rule\n { name = \" \"\n , pattern =\n [ Predicate isCurrencyOnly\n , Predicate isPositive\n ]\n , prod = \\case\n (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.currency = c}:\n Token Numeral NumeralData{TNumeral.value = v}:\n _) -> Just . Token AmountOfMoney . withValue v $ currencyOnly c\n _ -> Nothing\n }\n\nruleIntersectAndNumeral :: Rule\nruleIntersectAndNumeral = Rule\n { name = \"intersect (and number)\"\n , pattern =\n [ Predicate isWithoutCents\n , regex \"och\"\n , Predicate isNatural\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n _:\n Token Numeral NumeralData{TNumeral.value = c}:\n _) -> Just . Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nruleAboutAmountofmoney :: Rule\nruleAboutAmountofmoney = Rule\n { name = \"about \"\n , pattern =\n [ regex \"omkring|cirka|runt|ca\"\n , Predicate isMoneyWithValue\n ]\n , prod = \\tokens -> case tokens of\n (_:token:_) -> Just token\n _ -> Nothing\n }\n\nruleCent :: Rule\nruleCent = Rule\n { name = \"cent\"\n , pattern =\n [ regex \"cents?|penn(y|ies)|\u00c3\u00b6re\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly Cent\n }\n\nruleExactlyAmountofmoney :: Rule\nruleExactlyAmountofmoney = Rule\n { name = \"exactly \"\n , pattern =\n [ regex \"exakt|precis\"\n , Predicate isMoneyWithValue\n ]\n , prod = \\tokens -> case tokens of\n (_:token:_) -> Just token\n _ -> Nothing\n }\n\nruleIntersectXCents :: Rule\nruleIntersectXCents = Rule\n { name = \"intersect (X cents)\"\n , pattern =\n [ Predicate isWithoutCents\n , Predicate isCents\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just c}:\n _) -> Just . Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nruleNok :: Rule\nruleNok = Rule\n { name = \"NOK\"\n , pattern =\n [ regex \"norska kronor|nkr\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly NOK\n }\n\nrulePounds :: Rule\nrulePounds = Rule\n { name = \"\u00c2\u00a3\"\n , pattern =\n [ regex \"pund?\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly Pound\n }\n\nruleIntersectAndXCents :: Rule\nruleIntersectAndXCents = Rule\n { name = \"intersect (and X cents)\"\n , pattern =\n [ Predicate isWithoutCents\n , regex \"och\"\n , Predicate isCents\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just c}:\n _) -> Just . Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nruleIntersect :: Rule\nruleIntersect = Rule\n { name = \"intersect\"\n , pattern =\n [ Predicate isWithoutCents\n , Predicate isNatural\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n Token Numeral NumeralData{TNumeral.value = c}:\n _) -> Just . Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nruleSek :: Rule\nruleSek = Rule\n { name = \"SEK\"\n , pattern =\n [ regex \"kr(onor)?\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly SEK\n }\n\nruleDirham :: Rule\nruleDirham = Rule\n { name = \"AED\"\n , pattern =\n [ regex \"dirhams?\"\n ]\n , prod = \\_ -> Just . Token AmountOfMoney $ currencyOnly AED\n }\n\nrules :: [Rule]\nrules =\n [ ruleUnitAmount\n , ruleAboutAmountofmoney\n , ruleCent\n , ruleDirham\n , ruleExactlyAmountofmoney\n , ruleIntersect\n , ruleIntersectAndNumeral\n , ruleIntersectAndXCents\n , ruleIntersectXCents\n , ruleNok\n , rulePounds\n , ruleSek\n ]\n", "num_lines": 187} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.TR.Corpus\n ( corpus\n ) where\n\nimport Data.String (fromString)\nimport Prelude\n\nimport Duckling.AmountOfMoney.Types\nimport Duckling.Testing.Types\nimport Duckling.Locale\nimport Duckling.Resolve\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale TR Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple TRY 10000)\n [ \"10 bin lira\"\n , \"on bin lira\"\n , \"10000 lira\"\n ]\n , examples (simple TRY 1)\n [ \"bir lira\"\n , \"1 lira\"\n ]\n , examples (simple Cent 10)\n [ \"on kuru\u00c5\u0178\"\n , \"10 kuru\u00c5\u0178\"\n ]\n , examples (simple Cent 25)\n [ \"25 kuru\u00c5\u0178\"\n , \"yirmi be\u00c5\u0178 kuru\u00c5\u0178\"\n ]\n , examples (simple Cent 5)\n [ \"be\u00c5\u0178 kuru\u00c5\u0178\"\n , \"5 kuru\u00c5\u0178\"\n ]\n , examples (simple Cent 66)\n [ \"altm\u00c4\u00b1\u00c5\u0178 alt\u00c4\u00b1 kuru\u00c5\u0178\"\n , \"66 kuru\u00c5\u0178\"\n ]\n , examples (simple TRY 100.75)\n [ \"y\u00c3\u00bcz lira yetmi\u00c5\u0178 be\u00c5\u0178 kuru\u00c5\u0178\"\n , \"100 lira 75 kuru\u00c5\u0178\"\n ]\n ]\n", "num_lines": 56} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.AmountOfMoney.TR.Rules\n ( rules\n ) where\n\nimport Data.String (fromString)\nimport Prelude\n\nimport Duckling.AmountOfMoney.Helpers\nimport Duckling.AmountOfMoney.Types (Currency(..), AmountOfMoneyData (..))\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers (isNatural, isPositive)\nimport Duckling.Numeral.Types (NumeralData (..))\nimport Duckling.Types\nimport qualified Duckling.AmountOfMoney.Types as TAmountOfMoney\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleUnitAmount :: Rule\nruleUnitAmount = Rule\n { name = \" \"\n , pattern =\n [ Predicate isCurrencyOnly\n , Predicate isPositive\n ]\n , prod = \\case\n (Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.currency = c}:\n Token Numeral NumeralData{TNumeral.value = v}:\n _) -> Just $ Token AmountOfMoney $ withValue v $ currencyOnly c\n _ -> Nothing\n }\n\nrulePounds :: Rule\nrulePounds = Rule\n { name = \"\u00e2\u201a\u00ba\"\n , pattern =\n [ regex \"\u00e2\u201a\u00ba\"\n ]\n , prod = \\_ -> Just $ Token AmountOfMoney $ currencyOnly TRY\n }\n\nruleCent :: Rule\nruleCent = Rule\n { name = \"cent\"\n , pattern =\n [ regex \"kuru\u00c5\u0178?\"\n ]\n , prod = \\_ -> Just $ Token AmountOfMoney $ currencyOnly Cent\n }\n\nruleADollarCoin :: Rule\nruleADollarCoin = Rule\n { name = \"a \"\n , pattern =\n [ regex \"kuru\u00c5\u0178\"\n , Predicate isDollarCoin\n ]\n , prod = \\tokens -> case tokens of\n (_:\n Token AmountOfMoney fd:\n _) -> Just $ Token AmountOfMoney fd\n _ -> Nothing\n }\n\nruleNumDollarCoins :: Rule\nruleNumDollarCoins = Rule\n { name = \"X \"\n , pattern =\n [ Predicate isNatural\n , Predicate isDollarCoin\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = c}:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just d,\n TAmountOfMoney.currency = cur}:\n _) -> Just $ Token AmountOfMoney $ withValue (c * d) $ currencyOnly cur\n _ -> Nothing\n }\n\nruleIntersectAndXCents :: Rule\nruleIntersectAndXCents = Rule\n { name = \"intersect (and X cents)\"\n , pattern =\n [ Predicate isWithoutCents\n , regex \"(lira|tl)\"\n , Predicate isCents\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n _:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just c}:\n _) -> Just $ Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nruleIntersect :: Rule\nruleIntersect = Rule\n { name = \"intersect\"\n , pattern =\n [ Predicate isWithoutCents\n , Predicate isNatural\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n Token Numeral NumeralData{TNumeral.value = c}:\n _) -> Just $ Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nruleIntersectAndNumeral :: Rule\nruleIntersectAndNumeral = Rule\n { name = \"intersect (and number)\"\n , pattern =\n [ Predicate isWithoutCents\n , regex \"(lira|tl)\"\n , Predicate isNatural\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n _:\n Token Numeral NumeralData{TNumeral.value = c}:\n _) -> Just $ Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nruleIntersectXCents :: Rule\nruleIntersectXCents = Rule\n { name = \"intersect (X cents)\"\n , pattern =\n [ Predicate isWithoutCents\n , Predicate isCents\n ]\n , prod = \\tokens -> case tokens of\n (Token AmountOfMoney fd:\n Token AmountOfMoney AmountOfMoneyData{TAmountOfMoney.value = Just c}:\n _) -> Just $ Token AmountOfMoney $ withCents c fd\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleUnitAmount\n , ruleCent\n , ruleADollarCoin\n , ruleNumDollarCoins\n , ruleIntersect\n , ruleIntersectAndNumeral\n , ruleIntersectAndXCents\n , ruleIntersectXCents\n , rulePounds\n ]\n", "num_lines": 161} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.CreditCardNumber.Corpus\n ( corpus\n , negativeCorpus\n ) where\n\nimport Prelude\nimport Data.String\nimport qualified Data.Text as T\n\nimport Duckling.CreditCardNumber.Types\nimport Duckling.CreditCardNumber.Helpers\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext, testOptions, allExamples)\n\nnegativeCorpus :: NegativeCorpus\nnegativeCorpus = (testContext, testOptions, examples)\n where\n examples =\n [ T.replicate (minNumberDigits - 1) \"0\"\n , T.replicate (maxNumberDigits + 1) \"0\"\n , \"invalid\"\n , \"4111111111111110\"\n , \"41111111-1111-1111\"\n , \"371449635398430\"\n , \"3714496353-98431\"\n , \"6011111111111110\"\n , \"60111111-1111-1117\"\n , \"5555555555554440\"\n , \"55555555-5555-4444\"\n , \"30569309025900\"\n , \"3056930902-5904\"\n ]\n\nallExamples :: [Example]\nallExamples = concat\n [ examples\n (CreditCardNumberValue \"4111111111111111\" Visa)\n [ \"4111111111111111\"\n , \"4111-1111-1111-1111\"\n ]\n , examples\n (CreditCardNumberValue \"371449635398431\" Amex)\n [ \"371449635398431\"\n , \"3714-496353-98431\"\n ]\n , examples\n (CreditCardNumberValue \"6011111111111117\" Discover)\n [ \"6011111111111117\"\n , \"6011-1111-1111-1117\"\n ]\n , examples\n (CreditCardNumberValue \"5555555555554444\" Mastercard)\n [ \"5555555555554444\"\n , \"5555-5555-5555-4444\"\n ]\n , examples\n (CreditCardNumberValue \"30569309025904\" DinerClub)\n [ \"30569309025904\"\n , \"3056-930902-5904\"\n ]\n , examples\n (CreditCardNumberValue \"3530111333300000\" Other)\n [ \"3530111333300000\" ]\n ]\n", "num_lines": 76} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.CreditCardNumber.Helpers\n ( otherCreditCardNumberRegex\n , visaCreditCardNumberRegex\n , amexCreditCardNumberRegex\n , discoverCreditCardNumberRegex\n , mastercardCreditCardNumberRegex\n , dinerClubCreditCardNumberRegex\n , isValidCreditCardNumber\n , minNumberDigits\n , maxNumberDigits\n , creditCard\n ) where\n\nimport Data.Text (Text)\nimport Prelude\nimport Data.String\n\nimport Duckling.CreditCardNumber.Types (CreditCardNumberData(..))\nimport qualified Duckling.CreditCardNumber.Types as TCreditCardNumber\nimport qualified Data.Text as T\nimport qualified Data.Char as C\nimport qualified Data.Bits as B\n\n-- -----------------------------------------------------------------\n-- Patterns\n\notherCreditCardNumberRegex :: String\notherCreditCardNumberRegex =\n concat [ \"(\"\n , \"(?!\" , visaCreditCardNumberRegex, \")\"\n , \"(?!\" , amexCreditCardNumberRegex, \")\"\n , \"(?!\" , discoverCreditCardNumberRegex, \")\"\n , \"(?!\" , mastercardCreditCardNumberRegex, \")\"\n , \"(?!\" , dinerClubCreditCardNumberRegex, \")\"\n , \"\\\\d{\" , show minNumberDigits , \",\" , show maxNumberDigits , \"}\"\n , \")\"\n ]\n\n-- | Visa credit card regex informed by latest BIN info\nvisaCreditCardNumberRegex :: String\nvisaCreditCardNumberRegex = \"(\" ++ withoutDashes ++ \"|\" ++ withDashes ++\")\"\n where\n withoutDashes = \"4[0-9]{15}\"\n withDashes = \"4[0-9]{3}-[0-9]{4}-[0-9]{4}-[0-9]{4}\"\n\n-- | American Express credit card regex informed by latest BIN info\namexCreditCardNumberRegex :: String\namexCreditCardNumberRegex = \"(\" ++ withoutDashes ++ \"|\" ++ withDashes ++\")\"\n where\n withoutDashes = \"3[47][0-9]{13}\"\n withDashes = \"3[47][0-9]{2}-[0-9]{6}-[0-9]{5}\"\n\n-- | Discover credit card regex informed by latest BIN info\ndiscoverCreditCardNumberRegex :: String\ndiscoverCreditCardNumberRegex = \"(\" ++ withoutDashes ++ \"|\" ++ withDashes ++\")\"\n where\n withoutDashes = \"6(?:011|[45][0-9]{2})[0-9]{12}\"\n withDashes = \"6(?:011|[45][0-9]{2})-[0-9]{4}-[0-9]{4}-[0-9]{4}\"\n\n-- | Mastercard credit card regex informed by latest BIN info\nmastercardCreditCardNumberRegex :: String\nmastercardCreditCardNumberRegex =\n \"(\" ++ withoutDashes ++ \"|\" ++ withDashes ++\")\"\n where\n withoutDashes = \"5[1-5][0-9]{14}\"\n withDashes = \"5[1-5][0-9]{2}-[0-9]{4}-[0-9]{4}-[0-9]{4}\"\n\n-- | Diner Club credit card regex informed by latest BIN info\ndinerClubCreditCardNumberRegex :: String\ndinerClubCreditCardNumberRegex = \"(\" ++ withoutDashes ++ \"|\" ++ withDashes ++\")\"\n where\n withoutDashes = \"3(?:0[0-5]|[68][0-9])[0-9]{11}\"\n withDashes = \"3(?:0[0-5]|[68][0-9])[0-9]-[0-9]{6}-[0-9]{4}\"\n\n-- -----------------------------------------------------------------\n-- Validation\n\n-- | An implementation of the Luhn algorithm (see\n-- https://en.wikipedia.org/wiki/Luhn_algorithm) to check if a given credit card\n-- number is valid\nisValidCreditCardNumber :: Text -> Bool\nisValidCreditCardNumber ccNum =\n T.length ccNum >= minNumberDigits &&\n T.length ccNum <= maxNumberDigits &&\n validCheckSum\n where\n validCheckSum :: Bool\n validCheckSum =\n T.all C.isDigit ccNum &&\n fst (T.foldr f (0, 0) ccNum) `rem` 10 == 0\n where\n f char (checksum, e) =\n let\n val = C.digitToInt char\n -- every even digit should be doubled\n d = sumDigits (B.shift val e)\n in (checksum + d, 1 - e)\n -- we only need sum of digits for numbers from 0 to 18\n sumDigits a\n | a > 9 = a - 9\n | otherwise = a\n\nminNumberDigits :: Int\nminNumberDigits = 8\n\nmaxNumberDigits :: Int\nmaxNumberDigits = 19\n\n-- -----------------------------------------------------------------\n-- Production\n\ncreditCard :: Text -> TCreditCardNumber.Issuer -> CreditCardNumberData\ncreditCard ccNum i =\n CreditCardNumberData { TCreditCardNumber.number = ccNum\n , TCreditCardNumber.issuer = i\n }\n", "num_lines": 124} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.CreditCardNumber.Rules\n ( rules ) where\n\nimport Prelude\nimport Data.String\nimport Data.Text (Text)\nimport Data.Bool\nimport qualified Data.Text as T\nimport qualified Data.Char as C\n\nimport Duckling.Dimensions.Types\nimport Duckling.CreditCardNumber.Helpers\nimport qualified Duckling.CreditCardNumber.Types as TCreditCardNumber\nimport Duckling.Regex.Types\nimport Duckling.Types\n\ncreditCards :: [(Text, PatternItem, TCreditCardNumber.Issuer)]\ncreditCards =\n [ ( \"visa credit card number\"\n , regex visaCreditCardNumberRegex\n , TCreditCardNumber.Visa\n )\n , ( \"amex card number\"\n , regex amexCreditCardNumberRegex\n , TCreditCardNumber.Amex\n )\n , ( \"discover card number\"\n , regex discoverCreditCardNumberRegex\n , TCreditCardNumber.Discover\n )\n , ( \"mastercard card number\"\n , regex mastercardCreditCardNumberRegex\n , TCreditCardNumber.Mastercard\n )\n , ( \"diner club card number\"\n , regex dinerClubCreditCardNumberRegex\n , TCreditCardNumber.DinerClub\n )\n , ( \"credit card number\"\n , regex otherCreditCardNumberRegex\n , TCreditCardNumber.Other\n )\n ]\n\nrules :: [Rule]\nrules = map go creditCards\n where\n go :: (Text, PatternItem, TCreditCardNumber.Issuer) -> Rule\n go (name, regexPattern, i) = Rule\n { name = name\n , pattern = [ regexPattern ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (ccNumGroup:_)):_) ->\n bool\n Nothing\n (Just $ Token CreditCardNumber $ creditCard ccNum i)\n (isValidCreditCardNumber ccNum)\n where\n ccNum = T.filter C.isDigit ccNumGroup\n _ -> Nothing\n }\n", "num_lines": 73} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE DeriveAnyClass #-}\n{-# LANGUAGE NamedFieldPuns #-}\n{-# LANGUAGE DeriveGeneric #-}\n{-# LANGUAGE NoRebindableSyntax #-}\n{-# LANGUAGE OverloadedStrings #-}\n{-# LANGUAGE TypeFamilies #-}\n\nmodule Duckling.CreditCardNumber.Types where\n\nimport Control.DeepSeq\nimport Data.Aeson\nimport Data.Hashable\nimport Data.Text (Text)\nimport qualified Data.Text as Text\nimport GHC.Generics\n\nimport Prelude\n\nimport Duckling.Resolve (Resolve(..))\n\ndata Issuer\n = Visa\n | Amex\n | Discover\n | Mastercard\n | DinerClub\n | Other\n deriving (Eq, Generic, Hashable, Ord, Show, NFData)\n\ninstance ToJSON Issuer where\n toJSON = String . Text.toLower . Text.pack . show\n\ndata CreditCardNumberData = CreditCardNumberData\n { number :: Text\n , issuer :: Issuer\n }\n deriving (Eq, Generic, Hashable, Ord, Show, NFData)\n\ninstance Resolve CreditCardNumberData where\n type ResolvedValue CreditCardNumberData = CreditCardNumberValue\n resolve _ _ CreditCardNumberData {number, issuer} =\n Just (CreditCardNumberValue number issuer, False)\n\ndata CreditCardNumberValue = CreditCardNumberValue\n { vNumber :: Text\n , vIssuer :: Issuer\n }\n deriving (Eq, Ord, Show)\n\ninstance ToJSON CreditCardNumberValue where\n toJSON (CreditCardNumberValue number issuer) =\n object [ \"value\" .= number\n , \"issuer\" .= issuer\n ]\n", "num_lines": 62} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.AF\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Numeral\n ]\n", "num_lines": 18} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.AR\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Duration\n , Seal Numeral\n , Seal Ordinal\n , Seal Quantity\n , Seal Temperature\n , Seal Time\n , Seal Volume\n ]\n", "num_lines": 24} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.BG\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Distance\n , Seal Duration\n , Seal Numeral\n , Seal Ordinal\n , Seal Time\n ]\n", "num_lines": 22} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.BN\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Numeral\n ]\n", "num_lines": 18} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.CA\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal AmountOfMoney\n , Seal Distance\n , Seal Duration\n , Seal Numeral\n , Seal Ordinal\n , Seal Temperature\n , Seal Time\n , Seal Volume\n ]\n", "num_lines": 25} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.Common\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal AmountOfMoney\n , Seal CreditCardNumber\n , Seal Email\n , Seal Numeral\n , Seal PhoneNumber\n , Seal Url\n ]\n", "num_lines": 23} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.CS\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Distance\n , Seal Numeral\n ]\n", "num_lines": 19} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.DA\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Duration\n , Seal Numeral\n , Seal Ordinal\n , Seal Time\n ]\n", "num_lines": 21} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.DE\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Distance\n , Seal Duration\n , Seal Numeral\n , Seal Ordinal\n , Seal Time\n , Seal Volume\n ]\n", "num_lines": 23} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.EL\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Duration\n , Seal Numeral\n , Seal Ordinal\n , Seal Time\n ]\n", "num_lines": 21} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.EN\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Distance\n , Seal Duration\n , Seal Numeral\n , Seal Ordinal\n , Seal Quantity\n , Seal Temperature\n , Seal Time\n , Seal Volume\n ]\n", "num_lines": 25} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.ES\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Distance\n , Seal Duration\n , Seal Numeral\n , Seal Ordinal\n , Seal Quantity\n , Seal Temperature\n , Seal Time\n , Seal Volume\n ]\n", "num_lines": 25} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.ET\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Numeral\n , Seal Ordinal\n ]\n", "num_lines": 19} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\nmodule Duckling.Dimensions.FA\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Numeral\n ]\n", "num_lines": 17} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\nmodule Duckling.Dimensions.FI\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Numeral\n ]\n", "num_lines": 17} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.FR\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Distance\n , Seal Duration\n , Seal Numeral\n , Seal Ordinal\n , Seal Quantity\n , Seal Temperature\n , Seal Time\n , Seal Volume\n ]\n", "num_lines": 25} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.GA\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Distance\n , Seal Duration\n , Seal Numeral\n , Seal Ordinal\n , Seal Temperature\n , Seal Time\n , Seal Volume\n ]\n", "num_lines": 24} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.HE\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Duration\n , Seal Numeral\n , Seal Ordinal\n , Seal Time\n ]\n", "num_lines": 21} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.HI\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Duration\n , Seal Numeral\n , Seal Ordinal\n , Seal Temperature\n ]\n", "num_lines": 21} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.HR\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Distance\n , Seal Duration\n , Seal Numeral\n , Seal Ordinal\n , Seal Quantity\n , Seal Temperature\n , Seal Time\n , Seal Volume\n ]\n", "num_lines": 25} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.HU\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Duration\n , Seal Numeral\n , Seal Ordinal\n , Seal Time\n ]\n", "num_lines": 21} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.ID\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Numeral\n , Seal Ordinal\n ]\n", "num_lines": 19} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.IS\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Numeral\n ]\n", "num_lines": 18} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.IT\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Distance\n , Seal Duration\n , Seal Numeral\n , Seal Ordinal\n , Seal Temperature\n , Seal Time\n , Seal Volume\n ]\n", "num_lines": 24} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.JA\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Duration\n , Seal Numeral\n , Seal Ordinal\n , Seal Temperature\n , Seal Time\n ]\n", "num_lines": 22} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.KA\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Numeral\n , Seal Ordinal\n , Seal Duration\n , Seal Time\n ]\n", "num_lines": 21} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.KM\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Distance\n , Seal Numeral\n , Seal Ordinal\n , Seal Quantity\n , Seal Temperature\n , Seal Volume\n ]\n", "num_lines": 23} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.KN\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Numeral\n ]\n", "num_lines": 18} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.KO\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Distance\n , Seal Duration\n , Seal Numeral\n , Seal Ordinal\n , Seal Quantity\n , Seal Temperature\n , Seal Time\n , Seal Volume\n ]\n", "num_lines": 25} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.LO\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Numeral\n ]\n", "num_lines": 18} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.ML\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Numeral,\n Seal Ordinal\n ]\n", "num_lines": 19} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.MN\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Distance\n , Seal Duration\n , Seal Numeral\n , Seal Ordinal\n , Seal Quantity\n , Seal Temperature\n , Seal Volume\n ]\n", "num_lines": 24} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.MY\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Numeral\n ]\n", "num_lines": 18} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.NB\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Duration\n , Seal Numeral\n , Seal Ordinal\n , Seal Time\n ]\n", "num_lines": 21} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.NE\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Numeral\n ]\n", "num_lines": 18} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.NL\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Distance\n , Seal Duration\n , Seal Numeral\n , Seal Ordinal\n , Seal Quantity\n , Seal Time\n , Seal Volume\n ]\n", "num_lines": 24} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.PL\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Duration\n , Seal Numeral\n , Seal Ordinal\n , Seal Time\n ]\n", "num_lines": 21} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.PT\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Distance\n , Seal Duration\n , Seal Numeral\n , Seal Ordinal\n , Seal Quantity\n , Seal Temperature\n , Seal Time\n , Seal Volume\n ]\n", "num_lines": 25} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.RO\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Distance\n , Seal Duration\n , Seal Numeral\n , Seal Ordinal\n , Seal Quantity\n , Seal Temperature\n , Seal Time\n , Seal Volume\n ]\n", "num_lines": 25} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.RU\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Distance\n , Seal Duration\n , Seal Numeral\n , Seal Ordinal\n , Seal Quantity\n , Seal Volume\n , Seal Time\n ]\n", "num_lines": 24} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree. An additional grant\n-- of patent rights can be found in the PATENTS file in the same directory.\n\n\nmodule Duckling.Dimensions.SK\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Numeral\n ]\n", "num_lines": 19} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.SV\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Distance\n , Seal Duration\n , Seal Numeral\n , Seal Ordinal\n , Seal Time\n ]\n", "num_lines": 22} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.SW\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Numeral\n ]\n", "num_lines": 18} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.TA\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Numeral\n , Seal Ordinal\n ]\n", "num_lines": 19} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.TE\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Numeral\n ]\n", "num_lines": 18} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.TH\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Numeral\n ]\n", "num_lines": 18} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.TR\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Distance\n , Seal Duration\n , Seal Numeral\n , Seal Ordinal\n , Seal Temperature\n , Seal Time\n , Seal Volume\n ]\n", "num_lines": 24} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE NoRebindableSyntax #-}\n\n\nmodule Duckling.Dimensions.Types\n ( Seal(..)\n , Dimension(..)\n\n , fromName\n , toName\n ) where\n\nimport Data.Maybe\nimport Data.Text (Text)\nimport Prelude\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\n\nimport Duckling.Types\n\ntoName :: Dimension a -> Text\ntoName RegexMatch = \"regex\"\ntoName CreditCardNumber = \"credit-card-number\"\ntoName Distance = \"distance\"\ntoName Duration = \"duration\"\ntoName Email = \"email\"\ntoName AmountOfMoney = \"amount-of-money\"\ntoName Numeral = \"number\"\ntoName Ordinal = \"ordinal\"\ntoName PhoneNumber = \"phone-number\"\ntoName Quantity = \"quantity\"\ntoName Temperature = \"temperature\"\ntoName Time = \"time\"\ntoName TimeGrain = \"time-grain\"\ntoName Url = \"url\"\ntoName Volume = \"volume\"\ntoName (CustomDimension dim) = Text.pack (show dim)\n\nfromName :: Text -> Maybe (Seal Dimension)\nfromName name = HashMap.lookup name m\n where\n m = HashMap.fromList\n [ (\"amount-of-money\", Seal AmountOfMoney)\n , (\"credit-card-number\", Seal CreditCardNumber)\n , (\"distance\", Seal Distance)\n , (\"duration\", Seal Duration)\n , (\"email\", Seal Email)\n , (\"number\", Seal Numeral)\n , (\"ordinal\", Seal Ordinal)\n , (\"phone-number\", Seal PhoneNumber)\n , (\"quantity\", Seal Quantity)\n , (\"temperature\", Seal Temperature)\n , (\"time\", Seal Time)\n , (\"time-grain\", Seal TimeGrain)\n , (\"url\", Seal Url)\n , (\"volume\", Seal Volume)\n ]\n", "num_lines": 65} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.UK\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Duration\n , Seal Numeral\n , Seal Ordinal\n , Seal Time\n ]\n", "num_lines": 21} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.VI\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Duration\n , Seal Numeral\n , Seal Ordinal\n , Seal Time\n ]\n", "num_lines": 21} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Dimensions.ZH\n ( allDimensions\n ) where\n\nimport Duckling.Dimensions.Types\n\nallDimensions :: [Seal Dimension]\nallDimensions =\n [ Seal Distance\n , Seal Duration\n , Seal Numeral\n , Seal Ordinal\n , Seal Quantity\n , Seal Temperature\n , Seal Time\n ]\n", "num_lines": 24} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n\nmodule Duckling.Distance.Helpers\n ( distance\n , distanceSum\n , isDistanceOfUnit\n , isSimpleDistance\n , unitOnly\n , withInterval\n , withMax\n , withMin\n , withUnit\n , withValue\n ) where\n\nimport Prelude\nimport Data.Semigroup ((<>))\n\nimport Duckling.Dimensions.Types\nimport Duckling.Distance.Types (DistanceData(..))\nimport Duckling.Types\nimport qualified Duckling.Distance.Types as TDistance\nimport qualified Duckling.DistanceUnits.Types as DGTypes\n\n-- -----------------------------------------------------------------\n-- Patterns\n\nisSimpleDistance :: Predicate\nisSimpleDistance (Token Distance DistanceData {TDistance.value = Just _\n , TDistance.unit = Just _}) = True\nisSimpleDistance _ = False\n\nisDistanceOfUnit :: TDistance.Unit -> Predicate\nisDistanceOfUnit unit (Token Distance DistanceData {TDistance.unit = Just u}) =\n unit == u\nisDistanceOfUnit _ _ = False\n\n-- -----------------------------------------------------------------\n-- Production\n\ndistance :: Double -> DistanceData\ndistance x = DistanceData {TDistance.value = Just x\n , TDistance.unit = Nothing\n , TDistance.minValue = Nothing\n , TDistance.maxValue = Nothing}\n\ndistanceSum ::\n Double\n -> TDistance.Unit\n -> Double\n -> TDistance.Unit\n -> Maybe DistanceData\ndistanceSum v1 u1 v2 u2 = unwrapContext $ cd1 <> cd2\n where\n wrapContext v u = DGTypes.ContextualDistance v $ DGTypes.toSystemUnit u\n cd1 = wrapContext v1 u1\n cd2 = wrapContext v2 u2\n\n unwrapContext DGTypes.Nonrelatable = Nothing\n unwrapContext (DGTypes.ContextualDistance v u) =\n Just $ withUnit (DGTypes.toRawUnit u) $ distance v\n\nunitOnly :: TDistance.Unit -> DistanceData\nunitOnly u = DistanceData {TDistance.unit = Just u\n , TDistance.value = Nothing\n , TDistance.minValue = Nothing\n , TDistance.maxValue = Nothing}\n\nwithUnit :: TDistance.Unit -> DistanceData -> DistanceData\nwithUnit u dd = dd {TDistance.unit = Just u}\n\nwithValue :: Double -> DistanceData -> DistanceData\nwithValue value dd = dd {TDistance.value = Just value}\n\nwithInterval :: (Double, Double) -> DistanceData -> DistanceData\nwithInterval (from, to) dd = dd {TDistance.minValue = Just from\n , TDistance.maxValue = Just to}\n\nwithMin :: Double -> DistanceData -> DistanceData\nwithMin from dd = dd {TDistance.minValue = Just from}\n\nwithMax :: Double -> DistanceData -> DistanceData\nwithMax to dd = dd {TDistance.maxValue = Just to}\n", "num_lines": 91} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Distance.Rules\n ( rules\n ) where\n\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Dimensions.Types\nimport Duckling.Distance.Helpers\nimport Duckling.Numeral.Types (NumeralData (..))\nimport Duckling.Types\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleNumeralAsDistance :: Rule\nruleNumeralAsDistance = Rule\n { name = \"number as distance\"\n , pattern =\n [ dimension Numeral\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData {TNumeral.value = v}:_) ->\n Just . Token Distance $ distance v\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleNumeralAsDistance\n ]\n", "num_lines": 41} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE DeriveAnyClass #-}\n{-# LANGUAGE DeriveGeneric #-}\n{-# LANGUAGE NamedFieldPuns #-}\n{-# LANGUAGE NoRebindableSyntax #-}\n{-# LANGUAGE OverloadedStrings #-}\n{-# LANGUAGE TypeFamilies #-}\n\nmodule Duckling.Distance.Types where\n\nimport Control.DeepSeq\nimport Data.Aeson\nimport Data.Hashable\nimport Data.Text (Text)\nimport GHC.Generics\nimport Prelude\nimport qualified Data.HashMap.Strict as H\nimport qualified Data.Text as Text\n\nimport Duckling.Resolve (Resolve(..))\n\ndata Unit\n = Centimetre\n | Foot\n | Inch\n | Kilometre\n | M -- ambiguous between Mile and Metre\n | Metre\n | Mile\n | Millimetre\n | Yard\n deriving (Eq, Generic, Hashable, Ord, Show, NFData)\n\ninstance ToJSON Unit where\n toJSON = String . Text.toLower . Text.pack . show\n\ndata DistanceData = DistanceData\n { unit :: Maybe Unit\n , value :: Maybe Double\n , minValue :: Maybe Double\n , maxValue :: Maybe Double\n }\n deriving (Eq, Generic, Hashable, Ord, Show, NFData)\n\ninstance Resolve DistanceData where\n type ResolvedValue DistanceData = DistanceValue\n resolve _ _ DistanceData {unit = Just unit, value = Just val} =\n Just (simple unit val, False)\n resolve _ _ DistanceData {unit = Just unit, value = Nothing\n , minValue = Just from, maxValue = Just to} =\n Just (between unit (from, to), False)\n resolve _ _ DistanceData {unit = Just unit, value = Nothing\n , minValue = Just from, maxValue = Nothing} =\n Just (above unit from, False)\n resolve _ _ DistanceData {unit = Just unit, value = Nothing\n , minValue = Nothing, maxValue = Just to} =\n Just (under unit to, False)\n resolve _ _ _ = Nothing\n\ndata IntervalDirection = Above | Under\n deriving (Eq, Generic, Hashable, Ord, Show, NFData)\n\ndata SingleValue = SingleValue\n { vUnit :: Unit\n , vValue :: Double\n }\n deriving (Eq, Ord, Show)\n\ninstance ToJSON SingleValue where\n toJSON (SingleValue unit value) = object\n [ \"value\" .= value\n , \"unit\" .= unit\n ]\n\ndata DistanceValue\n = SimpleValue SingleValue\n | IntervalValue (SingleValue, SingleValue)\n | OpenIntervalValue (SingleValue, IntervalDirection)\n deriving (Eq, Ord, Show)\n\ninstance ToJSON DistanceValue where\n toJSON (SimpleValue value) = case toJSON value of\n Object o -> Object $ H.insert \"type\" (toJSON (\"value\" :: Text)) o\n _ -> Object H.empty\n toJSON (IntervalValue (from, to)) = object\n [ \"type\" .= (\"interval\" :: Text)\n , \"from\" .= toJSON from\n , \"to\" .= toJSON to\n ]\n toJSON (OpenIntervalValue (from, Above)) = object\n [ \"type\" .= (\"interval\" :: Text)\n , \"from\" .= toJSON from\n ]\n toJSON (OpenIntervalValue (to, Under)) = object\n [ \"type\" .= (\"interval\" :: Text)\n , \"to\" .= toJSON to\n ]\n\n-- -----------------------------------------------------------------\n-- Value helpers\n\nsimple :: Unit -> Double -> DistanceValue\nsimple u v = SimpleValue $ single u v\n\nbetween :: Unit -> (Double, Double) -> DistanceValue\nbetween u (from, to) = IntervalValue (single u from, single u to)\n\nabove :: Unit -> Double -> DistanceValue\nabove = openInterval Above\n\nunder :: Unit -> Double -> DistanceValue\nunder = openInterval Under\n\nopenInterval :: IntervalDirection -> Unit -> Double -> DistanceValue\nopenInterval direction u v = OpenIntervalValue (single u v, direction)\n\nsingle :: Unit -> Double -> SingleValue\nsingle u v = SingleValue {vUnit = u, vValue = v}\n", "num_lines": 125} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Distance.CA.Corpus\n ( corpus\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Distance.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale CA Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple Kilometre 3)\n [ \"3 kil\u00c3\u00b2metres\"\n , \"3 kilometres\"\n , \"3 kil\u00c3\u00b3metres\"\n , \"3 quil\u00c3\u00b2metres\"\n , \"3 km\"\n , \"3km\"\n ]\n , examples (simple Kilometre 3.0)\n [ \"3 km\"\n ]\n , examples (simple Mile 8)\n [ \"8 milles\"\n ]\n , examples (simple Metre 9)\n [ \"9m\"\n , \"9 metres\"\n , \"9 m\"\n ]\n , examples (simple Metre 1)\n [ \"1m\"\n , \"1 metre\"\n ]\n , examples (simple Centimetre 2)\n [ \"2cm\"\n , \"2 cent\u00c3\u00admetres\"\n , \"2 cm\"\n ]\n ]\n", "num_lines": 56} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Distance.CA.Rules\n ( rules ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Dimensions.Types\nimport Duckling.Distance.Helpers\nimport qualified Duckling.Distance.Types as TDistance\nimport Duckling.Types\n\nruleLatentDistKm :: Rule\nruleLatentDistKm = Rule\n { name = \" km\"\n , pattern =\n [ dimension Distance\n , regex \"(k|qu)(il(o|\u00c3\u00b2|\u00c3\u00b3))?m?(etre)?s?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just $ Token Distance $ withUnit TDistance.Kilometre dd\n _ -> Nothing\n }\n\nruleDistMeters :: Rule\nruleDistMeters = Rule\n { name = \" meters\"\n , pattern =\n [ dimension Distance\n , regex \"m(etres?)?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just $ Token Distance $ withUnit TDistance.Metre dd\n _ -> Nothing\n }\n\nruleDistCentimeters :: Rule\nruleDistCentimeters = Rule\n { name = \" centimeters\"\n , pattern =\n [ dimension Distance\n , regex \"(cm|cent(\u00c3\u00ad|i)m(etres?))\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just $ Token Distance $ withUnit TDistance.Centimetre dd\n _ -> Nothing\n }\n\nruleDistMiles :: Rule\nruleDistMiles = Rule\n { name = \" miles\"\n , pattern =\n [ dimension Distance\n , regex \"milles?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just $ Token Distance $ withUnit TDistance.Mile dd\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleDistCentimeters\n , ruleDistMeters\n , ruleDistMiles\n , ruleLatentDistKm\n ]\n", "num_lines": 81} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Distance.CS.Corpus\n ( corpus\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Distance.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale CS Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple Kilometre 3)\n [ \"3 kilometry\"\n , \"3 km\"\n , \"3km\"\n ]\n , examples (simple Mile 8)\n [ \"8 mil\"\n , \"osm mil\"\n ]\n , examples (simple Metre 1)\n [ \"1m\"\n , \"1 metr\"\n ]\n , examples (simple Metre 2)\n [ \"2m\"\n , \"2 metry\"\n ]\n , examples (simple Metre 9)\n [ \"9m\"\n , \"9 metr\u00c5\u00af\"\n ]\n , examples (simple Centimetre 1)\n [ \"1cm\"\n , \"1 centimetr\"\n ]\n , examples (simple Centimetre 2)\n [ \"2cm\"\n , \"2 centimetry\"\n ]\n , examples (simple Centimetre 9)\n [ \"9cm\"\n , \"9 centimetr\u00c5\u00af\"\n ]\n ]\n", "num_lines": 61} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Distance.CS.Rules\n ( rules ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Dimensions.Types\nimport Duckling.Distance.Helpers\nimport Duckling.Types\nimport qualified Duckling.Distance.Types as TDistance\n\nruleLatentDistKm :: Rule\nruleLatentDistKm = Rule\n { name = \" km\"\n , pattern =\n [ dimension Distance\n , regex \"km|kilometr(y|\\x016f)?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just . Token Distance $ withUnit TDistance.Kilometre dd\n _ -> Nothing\n }\n\nruleDistMeters :: Rule\nruleDistMeters = Rule\n { name = \" meters\"\n , pattern =\n [ dimension Distance\n , regex \"metr(y|\\x016f)?|m\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just . Token Distance $ withUnit TDistance.Metre dd\n _ -> Nothing\n }\n\nruleDistCentimeters :: Rule\nruleDistCentimeters = Rule\n { name = \" centimeters\"\n , pattern =\n [ dimension Distance\n , regex \"cm|centimetr(y|\\x016f)?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just . Token Distance $ withUnit TDistance.Centimetre dd\n _ -> Nothing\n }\n\nruleDistMiles :: Rule\nruleDistMiles = Rule\n { name = \" miles\"\n , pattern =\n [ dimension Distance\n , regex \"mil\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just . Token Distance $ withUnit TDistance.Mile dd\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleDistCentimeters\n , ruleDistMeters\n , ruleDistMiles\n , ruleLatentDistKm\n ]\n", "num_lines": 81} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Distance.DE.Corpus\n ( corpus\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Distance.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale DE Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple Kilometre 3)\n [ \"3 kilometer\"\n , \"3 km\"\n , \"3km\"\n , \"3,0 km\"\n ]\n , examples (simple Mile 8)\n [ \"acht meilen\"\n , \"8 meilen\"\n ]\n , examples (simple Metre 9)\n [ \"9m\"\n ]\n , examples (simple Centimetre 2)\n [ \"2cm\"\n , \"2 zentimeter\"\n ]\n , examples (simple Inch 5)\n [ \"5''\"\n , \"f\u00c3\u00bcnf zoll\"\n , \"5\\\"\"\n ]\n , examples (simple Metre 1.87)\n [ \"1,87 meter\"\n ]\n , examples (between Kilometre (3, 5))\n [ \"zwischen 3 und 5 kilometern\"\n , \"von 3km bis 5km\"\n , \"um die 3-5 kilometer\"\n , \"etwa 3km-5km\"\n , \"3-5 kilometer\"\n ]\n , examples (under Mile 3.5)\n [ \"unter 3,5 meilen\"\n , \"weniger als 3,5meilen\"\n --, \"niedriger als dreikommaf\u00c3\u00bcnf meilen\"\n ]\n , examples (above Inch 5)\n [ \"mehr als f\u00c3\u00bcnf zoll\"\n , \"mindestens 5''\"\n , \"\u00c3\u00bcber 5\\\"\"\n ]\n , examples (between Millimetre (5, 6))\n [ \"zwischen 5 und sechs Millimetern\"\n , \"zwischen 5 und sechs millimeter\"\n , \"5-6 mm\"\n ]\n ]\n", "num_lines": 75} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\nmodule Duckling.Distance.DE.Rules (rules) where\n\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\n\nimport Duckling.Dimensions.Types\nimport Duckling.Distance.Helpers\nimport Duckling.Distance.Types (DistanceData(..))\nimport qualified Duckling.Distance.Types as TDistance\nimport Duckling.Numeral.Helpers\nimport Duckling.Numeral.Types (NumeralData(..))\nimport qualified Duckling.Numeral.Types as TNumeral\nimport Duckling.Types\n\ndistances :: [(Text, String, TDistance.Unit)]\ndistances =\n [ -- Imperial\n (\"miles\", \"meilen?\", TDistance.Mile)\n , (\"inch\", \"(\\\"|''|zoll)\", TDistance.Inch)\n -- Metric\n , (\"km\", \"k(ilo)?m(etern?)?\", TDistance.Kilometre)\n , (\"meters\", \"m(etern?)?\", TDistance.Metre)\n , (\"centimeters\", \"(cm|[zc]entimetern?)\", TDistance.Centimetre)\n , (\"millimeters\", \"(mm|millimetern?)\", TDistance.Millimetre)\n ]\n\nrulePrecision :: Rule\nrulePrecision = Rule\n { name = \"about|exactly \"\n , pattern =\n [ regex \"genau|exakt|pr\u00c3\u00a4zise|ungef\u00c3\u00a4hr|(in )?etwa|nahe?( an)?|um( die)?|fast|rund|gut\"\n , dimension Distance\n ]\n , prod = \\case\n (_:token:_) -> Just token\n _ -> Nothing\n }\n\nruleDistances :: [Rule]\nruleDistances = map go distances\n where\n go :: (Text, String, TDistance.Unit) -> Rule\n go (name, regexPattern, u) = Rule\n { name = name\n , pattern = [ dimension Distance, regex regexPattern ]\n , prod = \\case\n (Token Distance dd:_) -> Just . Token Distance $ withUnit u dd\n _ -> Nothing\n }\n\nruleIntervalBetweenNumeral :: Rule\nruleIntervalBetweenNumeral = Rule\n { name = \"between|from to|and \"\n , pattern =\n [ regex \"zwischen|von\"\n , Predicate isPositive\n , regex \"bis|und\"\n , Predicate isSimpleDistance\n ]\n , prod = \\case\n (_:\n Token Numeral NumeralData{TNumeral.value = from}:\n _:\n Token Distance DistanceData{TDistance.value = Just to, TDistance.unit = Just u}:\n _) | from < to ->\n Just . Token Distance . withInterval (from, to) $ unitOnly u\n _ -> Nothing\n }\n\nruleIntervalBetween :: Rule\nruleIntervalBetween = Rule\n { name = \"between|from to|and \"\n , pattern =\n [ regex \"zwischen|von\"\n , Predicate isSimpleDistance\n , regex \"und|bis\"\n , Predicate isSimpleDistance\n ]\n , prod = \\case\n (_:\n Token Distance DistanceData{TDistance.value = Just from, TDistance.unit = Just u1}:\n _:\n Token Distance DistanceData{TDistance.value = Just to, TDistance.unit = Just u2}:\n _) | from < to && u1 == u2 ->\n Just . Token Distance . withInterval (from, to) $ unitOnly u1\n _ -> Nothing\n }\n\nruleIntervalNumeralDash :: Rule\nruleIntervalNumeralDash = Rule\n { name = \" - \"\n , pattern =\n [ Predicate isPositive\n , regex \"-\"\n , Predicate isSimpleDistance\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = from}:\n _:\n Token Distance DistanceData{TDistance.value = Just to, TDistance.unit = Just u}:\n _) | from < to ->\n Just . Token Distance . withInterval (from, to) $ unitOnly u\n _ -> Nothing\n }\n\nruleIntervalDash :: Rule\nruleIntervalDash = Rule\n { name = \" - \"\n , pattern =\n [ Predicate isSimpleDistance\n , regex \"-\"\n , Predicate isSimpleDistance\n ]\n , prod = \\case\n (Token Distance DistanceData{TDistance.value = Just from, TDistance.unit = Just u1}:\n _:\n Token Distance DistanceData{TDistance.value = Just to, TDistance.unit = Just u2}:\n _) | from < to && u1 == u2 ->\n Just . Token Distance . withInterval (from, to) $ unitOnly u1\n _ -> Nothing\n }\n\nruleIntervalMax :: Rule\nruleIntervalMax = Rule\n { name = \"under/less/lower/no more than \"\n , pattern =\n [ regex \"unter|h\u00c3\u00b6chstens|maximal|(weniger|nicht mehr) als\"\n , Predicate isSimpleDistance\n ]\n , prod = \\case\n (_:\n Token Distance DistanceData{TDistance.value = Just to, TDistance.unit = Just u}:\n _) -> Just . Token Distance . withMax to $ unitOnly u\n _ -> Nothing\n }\n\nruleIntervalMin :: Rule\nruleIntervalMin = Rule\n { name = \"over/above/at least/more than \"\n , pattern =\n [ regex \"\u00c3\u00bcber|(mehr|nicht weniger) als|mindestens|wenigstens|minimal\"\n , Predicate isSimpleDistance\n ]\n , prod = \\case\n (_:\n Token Distance DistanceData{TDistance.value = Just to, TDistance.unit = Just u}:\n _) -> Just . Token Distance . withMin to $ unitOnly u\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleIntervalBetweenNumeral\n , ruleIntervalBetween\n , ruleIntervalMax\n , ruleIntervalMin\n , ruleIntervalNumeralDash\n , ruleIntervalDash\n , rulePrecision\n ]\n ++ ruleDistances\n", "num_lines": 173} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Distance.EN.Corpus\n ( corpus\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Distance.Types\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple Kilometre 3)\n [ \"3 kilometers\"\n , \"3 km\"\n , \"3km\"\n , \"3k\"\n , \"3.0 km\"\n ]\n , examples (simple Mile 8)\n [ \"8 miles\"\n , \"eight mile\"\n , \"8 mi\"\n ]\n , examples (simple M 9)\n [ \"9m\"\n ]\n , examples (simple Centimetre 2)\n [ \"2cm\"\n , \"2 centimeters\"\n ]\n , examples (simple Inch 5)\n [ \"5 in\"\n , \"5''\"\n , \"five inches\"\n , \"5\\\"\"\n ]\n , examples (simple Metre 1.87)\n [ \"1.87 meters\"\n ]\n -- Composite values:\n , examples (simple Inch 94)\n [ \"7 feet and 10 inches\"\n , \"7 feet, 10 inches\"\n , \"7 feet 10 inches\"\n ]\n , examples (simple Metre 2001)\n [ \"2 km and 1 meter\"\n , \"2 kilometer, 1 metre\"\n , \"2 kilometer 1 metre\"\n ]\n , examples (simple Inch 166)\n [ \"2 yards 7 ft 10 inches\"\n , \"2 yds, 7 feet and 10 inches\"\n , \"2 yards, 7 feet, 10 in\"\n ]\n , examples (simple Foot 13)\n [ \"2 yards and 7 feet\"\n , \"2 yards, 7 feet\"\n , \"2 yd 7'\"\n ]\n , examples (simple Centimetre 1000806)\n [ \"10 kms 8 metres 6 cm\"\n , \"10 kms, 8 meters, 6 cm\"\n , \"10 kms, 8 meters and 6 centimeters\"\n-- , \"10 kms, 8 meters, and 6 cm\" -- Oxford comma not supported\n ]\n , examples (simple Metre 1.3048)\n [ \"1 meter and 1 foot\"\n ]\n , examples (simple Kilometre 2.609344)\n [ \"1 kilometer and 1 mile\"\n ]\n , examples (simple M 3)\n -- The original, ambiguous \"m\" unit is preserved\n [ \"3m\"\n ]\n , examples (simple Centimetre 305)\n -- The ambiguous \"m\" unit is inferred as \"meteres\"\n [ \"3m and 5cm\"\n ]\n , examples (simple Foot 5281)\n -- The ambiguous \"m\" unit is inferred as \"miles\"\n [ \"1m and 1ft\"\n ]\n -- Ranges:\n , examples (between Kilometre (3, 5))\n [ \"between 3 and 5 kilometers\"\n , \"from 3km to 5km\"\n , \"around 3-5 kilometers\"\n , \"about 3km-5km\"\n , \"3-5 kilometers\"\n ]\n , examples (under Mile 3.5)\n [ \"under 3.5 miles\"\n , \"less than 3.5mi\"\n , \"lower than three point five miles\"\n ]\n , examples (above Inch 5)\n [ \"more than five inches\"\n , \"at least 5''\"\n , \"over 5\\\"\"\n , \"above 5 in\"\n ]\n , examples (between Millimetre (5, 6))\n [ \"between 5 and six millimeters\"\n , \"between 5 and six millimetres\"\n , \"5-6 mm\"\n ]\n ]\n", "num_lines": 123} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Distance.EN.Rules\n ( rules ) where\n\n\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\n\nimport Duckling.Dimensions.Types\nimport Duckling.Distance.Helpers\nimport Duckling.Distance.Types (DistanceData(..))\nimport Duckling.Numeral.Helpers\nimport Duckling.Numeral.Types (NumeralData (..))\nimport Duckling.Types\nimport qualified Duckling.Distance.Types as TDist\nimport qualified Duckling.Numeral.Types as TNumeral\n\n\ndistances :: [(Text, String, TDist.Unit)]\ndistances = [ -- Imperial\n (\"miles\", \"mi(le(s)?)?\", TDist.Mile)\n , (\"yard\", \"y(ar)?ds?\", TDist.Yard)\n , (\"feet\", \"('|f(oo|ee)?ts?)\", TDist.Foot)\n , (\"inch\", \"(\\\"|''|in(ch(es)?)?)\", TDist.Inch)\n -- Metric\n , (\"km\", \"k(ilo)?m?(et(er|re))?s?\", TDist.Kilometre)\n , (\"meters\", \"met(er|re)s?\", TDist.Metre)\n , (\"centimeters\", \"cm|centimet(er|re)s?\", TDist.Centimetre)\n , (\"millimeters\", \"mm|millimet(er|re)s?\", TDist.Millimetre)\n -- Ambiguous\n , (\"m (miles or meters)\", \"m\", TDist.M)\n ]\n\nrulePrecision :: Rule\nrulePrecision = Rule\n { name = \"about|exactly \"\n , pattern =\n [ regex \"exactly|precisely|about|approx(\\\\.|imately)?|close to| near( to)?|around|almost\"\n , dimension Distance\n ]\n , prod = \\case\n (_:token:_) -> Just token\n _ -> Nothing\n }\n\nruleDistances :: [Rule]\nruleDistances = map go distances\n where\n go :: (Text, String, TDist.Unit) -> Rule\n go (name, regexPattern, u) = Rule\n { name = name\n , pattern = [ dimension Distance, regex regexPattern ]\n , prod = \\case\n (Token Distance dd:_) -> Just . Token Distance $ withUnit u dd\n _ -> Nothing\n }\n\nruleIntervalBetweenNumeral :: Rule\nruleIntervalBetweenNumeral = Rule\n { name = \"between|from to|and \"\n , pattern =\n [ regex \"between|from\"\n , Predicate isPositive\n , regex \"to|and\"\n , Predicate isSimpleDistance\n ]\n , prod = \\case\n (_:\n Token Numeral NumeralData{TNumeral.value = from}:\n _:\n Token Distance DistanceData{TDist.value=Just to, TDist.unit=Just u}:\n _) | from < to ->\n Just . Token Distance . withInterval (from, to) $ unitOnly u\n _ -> Nothing\n }\n\nruleIntervalBetween :: Rule\nruleIntervalBetween = Rule\n { name = \"between|from to|and \"\n , pattern =\n [ regex \"between|from\"\n , Predicate isSimpleDistance\n , regex \"to|and\"\n , Predicate isSimpleDistance\n ]\n , prod = \\case\n (_:\n Token Distance DistanceData{TDist.value=Just from, TDist.unit=Just u1}:\n _:\n Token Distance DistanceData{TDist.value=Just to, TDist.unit=Just u2}:\n _) | from < to && u1 == u2 ->\n Just . Token Distance . withInterval (from, to) $ unitOnly u1\n _ -> Nothing\n }\n\nruleIntervalNumeralDash :: Rule\nruleIntervalNumeralDash = Rule\n { name = \" - \"\n , pattern =\n [ Predicate isPositive\n , regex \"-\"\n , Predicate isSimpleDistance\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = from}:\n _:\n Token Distance DistanceData{TDist.value=Just to, TDist.unit=Just u}:\n _) | from < to ->\n Just . Token Distance . withInterval (from, to) $ unitOnly u\n _ -> Nothing\n }\n\nruleIntervalDash :: Rule\nruleIntervalDash = Rule\n { name = \" - \"\n , pattern =\n [ Predicate isSimpleDistance\n , regex \"-\"\n , Predicate isSimpleDistance\n ]\n , prod = \\case\n (Token Distance DistanceData{TDist.value=Just from, TDist.unit=Just u1}:\n _:\n Token Distance DistanceData{TDist.value=Just to, TDist.unit=Just u2}:\n _) | from < to && u1 == u2 ->\n Just . Token Distance . withInterval (from, to) $ unitOnly u1\n _ -> Nothing\n }\n\nruleIntervalMax :: Rule\nruleIntervalMax = Rule\n { name = \"under/less/lower/no more than \"\n , pattern =\n [ regex \"under|(less|lower|not? more) than\"\n , Predicate isSimpleDistance\n ]\n , prod = \\case\n (_:\n Token Distance DistanceData{TDist.value=Just to, TDist.unit=Just u}:\n _) -> Just . Token Distance . withMax to $ unitOnly u\n _ -> Nothing\n }\n\nruleIntervalMin :: Rule\nruleIntervalMin = Rule\n { name = \"over/above/at least/more than \"\n , pattern =\n [ regex \"over|above|at least|more than\"\n , Predicate isSimpleDistance\n ]\n , prod = \\case\n (_:\n Token Distance DistanceData{TDist.value=Just to, TDist.unit=Just u}:\n _) -> Just . Token Distance . withMin to $ unitOnly u\n _ -> Nothing\n }\n\n-- | NOTE: Oxford comma is not supported.\nruleCompositeDistanceCommasAnd :: Rule\nruleCompositeDistanceCommasAnd = Rule\n { name = \"composite (with ,/and)\"\n , pattern =\n [ Predicate isSimpleDistance\n , regex \",|and\"\n , Predicate isSimpleDistance\n ]\n , prod = \\case\n (Token Distance DistanceData{TDist.value=Just v1, TDist.unit=Just u1}:\n _:\n Token Distance DistanceData{TDist.value=Just v2, TDist.unit=Just u2}:\n _) | u1 /= u2 && v1 > 0 && v2 > 0 -> Token Distance <$>\n distanceSum v1 u1 v2 u2\n _ -> Nothing\n }\n\nruleCompositeDistance :: Rule\nruleCompositeDistance = Rule\n { name = \"composite \"\n , pattern =\n [ Predicate isSimpleDistance\n , Predicate isSimpleDistance\n ]\n , prod = \\case\n (Token Distance DistanceData{TDist.value=Just v1, TDist.unit=Just u1}:\n Token Distance DistanceData{TDist.value=Just v2, TDist.unit=Just u2}:\n _) | u1 /= u2 && v1 > 0 && v2 > 0 -> Token Distance <$>\n distanceSum v1 u1 v2 u2\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleIntervalBetweenNumeral\n , ruleIntervalBetween\n , ruleIntervalMax\n , ruleIntervalMin\n , ruleIntervalNumeralDash\n , ruleIntervalDash\n , rulePrecision\n , ruleCompositeDistanceCommasAnd\n , ruleCompositeDistance\n ] ++ ruleDistances\n", "num_lines": 214} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Distance.ES.Corpus\n ( corpus\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Distance.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale ES Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple Kilometre 3)\n [ \"3 kil\u00c3\u00b3metros\"\n , \"3 kilometros\"\n , \"3 km\"\n , \"3km\"\n , \"3k\"\n ]\n , examples (simple Kilometre 3.0)\n [ \"3,0 km\"\n ]\n , examples (simple Mile 8)\n [ \"8 miles\"\n ]\n , examples (simple Metre 9)\n [ \"9m\"\n , \"9 metros\"\n ]\n , examples (simple Centimetre 2)\n [ \"2cm\"\n , \"2 cent\u00c3\u00admetros\"\n ]\n ]\n", "num_lines": 49} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Distance.ES.Rules\n ( rules ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Dimensions.Types\nimport Duckling.Distance.Helpers\nimport qualified Duckling.Distance.Types as TDistance\nimport Duckling.Types\n\nruleLatentDistKm :: Rule\nruleLatentDistKm = Rule\n { name = \" km\"\n , pattern =\n [ dimension Distance\n , regex \"k(il(\u00c3\u00b3|o))?m?(etro)?s?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just . Token Distance $ withUnit TDistance.Kilometre dd\n _ -> Nothing\n }\n\nruleDistMeters :: Rule\nruleDistMeters = Rule\n { name = \" meters\"\n , pattern =\n [ dimension Distance\n , regex \"m(etros?)?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just . Token Distance $ withUnit TDistance.Metre dd\n _ -> Nothing\n }\n\nruleDistCentimeters :: Rule\nruleDistCentimeters = Rule\n { name = \" centimeters\"\n , pattern =\n [ dimension Distance\n , regex \"(cm|cent(\u00c3\u00ad|i)m(etros?))\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just . Token Distance $ withUnit TDistance.Centimetre dd\n _ -> Nothing\n }\n\nruleDistMiles :: Rule\nruleDistMiles = Rule\n { name = \" miles\"\n , pattern =\n [ dimension Distance\n , regex \"miles?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just . Token Distance $ withUnit TDistance.Mile dd\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleDistCentimeters\n , ruleDistMeters\n , ruleDistMiles\n , ruleLatentDistKm\n ]\n", "num_lines": 81} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Distance.FR.Corpus\n ( corpus ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Distance.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale FR Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple Kilometre 3)\n [ \"3 kilom\u00c3\u00a8tres\"\n , \"3 kilometres\"\n , \"3 km\"\n , \"3km\"\n , \"3k\"\n ]\n , examples (simple Kilometre 3.0)\n [ \"3,0 km\"\n ]\n , examples (simple Mile 8)\n [ \"8 miles\"\n ]\n , examples (simple Metre 9)\n [ \"9 metres\"\n , \"9m\"\n ]\n , examples (simple Centimetre 2)\n [ \"2cm\"\n , \"2 centimetres\"\n ]\n ]\n", "num_lines": 48} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Distance.FR.Rules\n ( rules ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Dimensions.Types\nimport Duckling.Distance.Helpers\nimport qualified Duckling.Distance.Types as TDistance\nimport Duckling.Types\n\nruleLatentDistKm :: Rule\nruleLatentDistKm = Rule\n { name = \" km\"\n , pattern =\n [ dimension Distance\n , regex \"k(ilo)?m?((e|\u00c3\u00a9|\u00c3\u00a8)tre)?s?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just . Token Distance $ withUnit TDistance.Kilometre dd\n _ -> Nothing\n }\n\nruleDistMeters :: Rule\nruleDistMeters = Rule\n { name = \" meters\"\n , pattern =\n [ dimension Distance\n , regex \"m((e|\u00c3\u00a9|\u00c3\u00a8)tres?)?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just . Token Distance $ withUnit TDistance.Metre dd\n _ -> Nothing\n }\n\nruleDistCentimeters :: Rule\nruleDistCentimeters = Rule\n { name = \" centimeters\"\n , pattern =\n [ dimension Distance\n , regex \"cm|centim(e|\u00c3\u00a9|\u00c3\u00a8)tres?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just . Token Distance $ withUnit TDistance.Centimetre dd\n _ -> Nothing\n }\n\nruleDistMiles :: Rule\nruleDistMiles = Rule\n { name = \" miles\"\n , pattern =\n [ dimension Distance\n , regex \"miles?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just . Token Distance $ withUnit TDistance.Mile dd\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleDistCentimeters\n , ruleDistMeters\n , ruleDistMiles\n , ruleLatentDistKm\n ]\n", "num_lines": 81} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Distance.GA.Corpus\n ( corpus ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Distance.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale GA Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple Kilometre 3)\n [ \"3 cilim\u00c3\u00a9adair\"\n , \"3 km\"\n , \"3km\"\n , \"3k\"\n ]\n , examples (simple Kilometre 3.0)\n [ \"3.0 km\"\n ]\n , examples (simple Mile 8)\n [ \"8 mh\u00c3\u00adle\"\n , \"8 m\u00c3\u00adle\"\n ]\n , examples (simple M 9)\n [ \"9m\"\n ]\n , examples (simple Centimetre 2)\n [ \"2cm\"\n , \"2 cheintim\u00c3\u00a9adar\"\n ]\n ]\n", "num_lines": 47} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Distance.GA.Rules\n ( rules ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Dimensions.Types\nimport Duckling.Distance.Helpers\nimport qualified Duckling.Distance.Types as TDistance\nimport Duckling.Types\n\nruleDistMeters :: Rule\nruleDistMeters = Rule\n { name = \" meters\"\n , pattern =\n [ dimension Distance\n , regex \"mh?(e|\u00c3\u00a9)adai?r\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just . Token Distance $ withUnit TDistance.Metre dd\n _ -> Nothing\n }\n\nruleDistCentimeters :: Rule\nruleDistCentimeters = Rule\n { name = \" centimeters\"\n , pattern =\n [ dimension Distance\n , regex \"(c\\\\.?m\\\\.?|g?ch?eintimh?(e|\u00c3\u00a9)adai?r)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just . Token Distance $ withUnit TDistance.Centimetre dd\n _ -> Nothing\n }\n\nruleDistMiles :: Rule\nruleDistMiles = Rule\n { name = \" miles\"\n , pattern =\n [ dimension Distance\n , regex \"mh?(\u00c3\u00ad|i)lt?e\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just . Token Distance $ withUnit TDistance.Mile dd\n _ -> Nothing\n }\n\nruleLatentDistKm :: Rule\nruleLatentDistKm = Rule\n { name = \" km\"\n , pattern =\n [ dimension Distance\n , regex \"(k\\\\.?(m\\\\.?)?|g?ch?ilim(e|\u00c3\u00a9)adai?r)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just . Token Distance $ withUnit TDistance.Kilometre dd\n _ -> Nothing\n }\n\nruleLatentDistTroigh :: Rule\nruleLatentDistTroigh = Rule\n { name = \" troigh\"\n , pattern =\n [ dimension Distance\n , regex \"('|d?th?roi[tg]he?|tr\\\\.?)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just . Token Distance $ withUnit TDistance.Foot dd\n _ -> Nothing\n }\n\nruleLatentDistOrlach :: Rule\nruleLatentDistOrlach = Rule\n { name = \" orlach\"\n , pattern =\n [ dimension Distance\n , regex \"(''|([nth]-?)?orl(ach|aigh|a(\u00c3\u00ad|i)|\\\\.))\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just . Token Distance $ withUnit TDistance.Inch dd\n _ -> Nothing\n }\n\nruleDistMAmbiguousMilesOrMeters :: Rule\nruleDistMAmbiguousMilesOrMeters = Rule\n { name = \" m (ambiguous miles or meters)\"\n , pattern =\n [ dimension Distance\n , regex \"m\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just . Token Distance $ withUnit TDistance.M dd\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleDistCentimeters\n , ruleDistMAmbiguousMilesOrMeters\n , ruleDistMeters\n , ruleDistMiles\n , ruleLatentDistKm\n , ruleLatentDistOrlach\n , ruleLatentDistTroigh\n ]\n", "num_lines": 123} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Distance.HR.Corpus\n ( corpus ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Distance.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale HR Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple Kilometre 3)\n [ \"3 kilometra\"\n , \"3 km\"\n , \"3km\"\n , \"3k\"\n ]\n , examples (simple Kilometre 3.0)\n [ \"3,0 km\"\n ]\n , examples (simple Mile 8)\n [ \"8 milja\"\n ]\n , examples (simple M 9)\n [ \"9m\"\n ]\n , examples (simple Centimetre 2)\n [ \"2cm\"\n , \"2 centimetra\"\n ]\n ]\n", "num_lines": 45} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Distance.HR.Rules\n ( rules ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Dimensions.Types\nimport Duckling.Distance.Helpers\nimport Duckling.Types\nimport qualified Duckling.Distance.Types as TDistance\n\nruleLatentDistKm :: Rule\nruleLatentDistKm = Rule\n { name = \" km\"\n , pattern =\n [ dimension Distance\n , regex \"k(ilo)?m?(eta?r)?a?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just . Token Distance $ withUnit TDistance.Kilometre dd\n _ -> Nothing\n }\n\nruleDistMetar :: Rule\nruleDistMetar = Rule\n { name = \" metar\"\n , pattern =\n [ dimension Distance\n , regex \"metara?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just . Token Distance $ withUnit TDistance.Metre dd\n _ -> Nothing\n }\n\nruleDistCentimetar :: Rule\nruleDistCentimetar = Rule\n { name = \" centimetar\"\n , pattern =\n [ dimension Distance\n , regex \"cm|centimeta?ra?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just . Token Distance $ withUnit TDistance.Centimetre dd\n _ -> Nothing\n }\n\nruleDistMilja :: Rule\nruleDistMilja = Rule\n { name = \" milja\"\n , pattern =\n [ dimension Distance\n , regex \"milja\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) -> Just . Token Distance $ withUnit TDistance.Mile dd\n _ -> Nothing\n }\n\nruleDistMAmbiguousMilesOrMeters :: Rule\nruleDistMAmbiguousMilesOrMeters = Rule\n { name = \" m (ambiguous miles or meters)\"\n , pattern =\n [ dimension Distance\n , regex \"m\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) -> Just . Token Distance $ withUnit TDistance.M dd\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleDistCentimetar\n , ruleDistMAmbiguousMilesOrMeters\n , ruleDistMetar\n , ruleDistMilja\n , ruleLatentDistKm\n ]\n", "num_lines": 92} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Distance.IT.Corpus\n ( corpus\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Distance.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncontext :: Context\ncontext = testContext {locale = makeLocale IT Nothing}\n\ncorpus :: Corpus\ncorpus = (context, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple Kilometre 3)\n [ \"3 kilometri\"\n , \"3 chilometri\"\n , \"3 km\"\n , \"3km\"\n ]\n , examples (simple Kilometre 3.0)\n [ \"3,0 km\"\n ]\n , examples (simple Mile 8)\n [ \"8 miglia\"\n ]\n , examples (simple Metre 9)\n [ \"9 metri\"\n , \"9m\"\n ]\n , examples (simple Centimetre 2)\n [ \"2cm\"\n , \"2 centimetri\"\n ]\n ]\n", "num_lines": 51} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Distance.IT.Rules\n ( rules\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Dimensions.Types\nimport Duckling.Distance.Helpers\nimport Duckling.Types\nimport qualified Duckling.Distance.Types as TDistance\n\nruleLatentDistKm :: Rule\nruleLatentDistKm = Rule\n { name = \" km\"\n , pattern =\n [ dimension Distance\n , regex \"km|(k|ch)(ilo)?m?(etr)o?i?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just . Token Distance $ withUnit TDistance.Kilometre dd\n _ -> Nothing\n }\n\nruleDistMeters :: Rule\nruleDistMeters = Rule\n { name = \" meters\"\n , pattern =\n [ dimension Distance\n , regex \"metro?i?|m\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just . Token Distance $ withUnit TDistance.Metre dd\n _ -> Nothing\n }\n\nruleDistCentimeters :: Rule\nruleDistCentimeters = Rule\n { name = \" centimeters\"\n , pattern =\n [ dimension Distance\n , regex \"cm|centimetro?i?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just . Token Distance $ withUnit TDistance.Centimetre dd\n _ -> Nothing\n }\n\nruleDistMiles :: Rule\nruleDistMiles = Rule\n { name = \" miles\"\n , pattern =\n [ dimension Distance\n , regex \"miglio?a?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just . Token Distance $ withUnit TDistance.Mile dd\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleDistCentimeters\n , ruleDistMeters\n , ruleDistMiles\n , ruleLatentDistKm\n ]\n", "num_lines": 82} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Distance.NL.Corpus\n ( corpus ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Distance.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale NL Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple Kilometre 3)\n [ \"3 kilometer\"\n , \"3 km\"\n , \"3km\"\n , \"3k\"\n ]\n , examples (simple Kilometre 3.0)\n [ \"3,0 km\"\n , \"3,0km\"\n ]\n , examples (simple Mile 8)\n [ \"8 mijl\"\n ]\n , examples (simple Metre 9)\n [ \"9m\"\n , \"9 m\"\n , \"9 meter\"\n ]\n , examples (simple Centimetre 2)\n [ \"2cm\"\n , \"2 cm\"\n , \"2 centimeter\"\n ]\n ]\n", "num_lines": 50} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Distance.NL.Rules\n ( rules ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Dimensions.Types\nimport Duckling.Distance.Helpers\nimport qualified Duckling.Distance.Types as TDistance\nimport Duckling.Types\n\nruleLatentDistKm :: Rule\nruleLatentDistKm = Rule\n { name = \" km\"\n , pattern =\n [ dimension Distance\n , regex \"k(ilo)?m?(eter)?s?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just . Token Distance $ withUnit TDistance.Kilometre dd\n _ -> Nothing\n }\n\nruleDistMeters :: Rule\nruleDistMeters = Rule\n { name = \" meters\"\n , pattern =\n [ dimension Distance\n , regex \"m(eter)?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just . Token Distance $ withUnit TDistance.Metre dd\n _ -> Nothing\n }\n\nruleDistCentimeters :: Rule\nruleDistCentimeters = Rule\n { name = \" centimeters\"\n , pattern =\n [ dimension Distance\n , regex \"(c(enti)?m(eter)?s?)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just . Token Distance $ withUnit TDistance.Centimetre dd\n _ -> Nothing\n }\n\nruleDistMiles :: Rule\nruleDistMiles = Rule\n { name = \" miles\"\n , pattern =\n [ dimension Distance\n , regex \"mijl?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just . Token Distance $ withUnit TDistance.Mile dd\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleDistCentimeters\n , ruleDistMeters\n , ruleDistMiles\n , ruleLatentDistKm\n ]\n", "num_lines": 81} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Distance.PT.Corpus\n ( corpus ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Distance.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale PT Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple Kilometre 3)\n [ \"3 kil\u00c3\u00b3metros\"\n , \"3 kilometros\"\n , \"3 km\"\n , \"3km\"\n , \"3k\"\n ]\n , examples (simple Kilometre 3.0)\n [ \"3,0 km\"\n ]\n , examples (simple Mile 8)\n [ \"8 milhas\"\n ]\n , examples (simple Metre 9)\n [ \"9m\"\n , \"9 metros\"\n ]\n , examples (simple Centimetre 2)\n [ \"2cm\"\n , \"2 cent\u00c3\u00admetros\"\n ]\n ]\n", "num_lines": 48} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Distance.PT.Rules\n ( rules ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Dimensions.Types\nimport Duckling.Distance.Helpers\nimport qualified Duckling.Distance.Types as TDistance\nimport Duckling.Types\n\nruleLatentDistKm :: Rule\nruleLatentDistKm = Rule\n { name = \" km\"\n , pattern =\n [ dimension Distance\n , regex \"k(il(\u00c3\u00b3|o))?m?(etro)?s?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just . Token Distance $ withUnit TDistance.Kilometre dd\n _ -> Nothing\n }\n\nruleDistMeters :: Rule\nruleDistMeters = Rule\n { name = \" meters\"\n , pattern =\n [ dimension Distance\n , regex \"m(etros?)?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just . Token Distance $ withUnit TDistance.Metre dd\n _ -> Nothing\n }\n\nruleDistCentimeters :: Rule\nruleDistCentimeters = Rule\n { name = \" centimeters\"\n , pattern =\n [ dimension Distance\n , regex \"(cm|cent(\u00c3\u00ad|i)m(etros?))\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just . Token Distance $ withUnit TDistance.Centimetre dd\n _ -> Nothing\n }\n\nruleDistMiles :: Rule\nruleDistMiles = Rule\n { name = \" miles\"\n , pattern =\n [ dimension Distance\n , regex \"milhas?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just . Token Distance $ withUnit TDistance.Mile dd\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleDistCentimeters\n , ruleDistMeters\n , ruleDistMiles\n , ruleLatentDistKm\n ]\n", "num_lines": 81} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Distance.RO.Corpus\n ( corpus ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Distance.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale RO Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple Kilometre 3)\n [ \"3 kilometri\"\n , \"3 km\"\n , \"3km\"\n , \"3,0 km\"\n ]\n , examples (simple Mile 8)\n [ \"8 mile\"\n ]\n , examples (simple Metre 9)\n [ \"9m\"\n , \"9 m\"\n ]\n , examples (simple Centimetre 2)\n [ \"2cm\"\n , \"2 centimetri\"\n ]\n , examples (simple Foot 10)\n [ \"zece picioare\"\n ]\n , examples (simple Foot 20)\n [ \"20 de picioare\"\n ]\n ]\n", "num_lines": 50} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Distance.RO.Rules\n ( rules\n ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Distance.Helpers\nimport Duckling.Regex.Types\nimport Duckling.Types\nimport qualified Duckling.Distance.Types as TDistance\n\nunitMap :: HashMap Text TDistance.Unit\nunitMap = HashMap.fromList\n [ ( \"cm\", TDistance.Centimetre )\n , ( \"centimetri\", TDistance.Centimetre )\n , ( \"centimetru\", TDistance.Centimetre )\n , ( \"picior\", TDistance.Foot )\n , ( \"picioare\", TDistance.Foot )\n , ( \"inch\", TDistance.Inch )\n , ( \"inchi\", TDistance.Inch )\n , ( \"inci\", TDistance.Inch )\n , ( \"km\", TDistance.Kilometre )\n , ( \"kilometri\", TDistance.Kilometre )\n , ( \"kilometru\", TDistance.Kilometre )\n , ( \"m\", TDistance.Metre )\n , ( \"metri\", TDistance.Metre )\n , ( \"metru\", TDistance.Metre )\n , ( \"mila\", TDistance.Mile )\n , ( \"mil\u00c4\u0192\", TDistance.Mile )\n , ( \"mile\", TDistance.Mile )\n , ( \"y\", TDistance.Yard )\n , ( \"yar\", TDistance.Yard )\n , ( \"yard\", TDistance.Yard )\n , ( \"yarzi\", TDistance.Yard )\n , ( \"yd\", TDistance.Yard )\n , ( \"yzi\", TDistance.Yard )\n ]\n\nruleLatentDistUnit :: Rule\nruleLatentDistUnit = Rule\n { name = \" foot/inch/yard/meter/kilometer/centimeter\"\n , pattern =\n [ dimension Distance\n , regex \"(inc(hi?|i)|(centi|kilo)?metr[iu]|mil[ea\u00c4\u0192]|[ck]?m|picio(are|r)|y(ar)?(zi|d)?)\"\n ]\n , prod = \\case\n (Token Distance dd:\n Token RegexMatch (GroupMatch (match:_)):\n _) -> do\n x <- HashMap.lookup (Text.toLower match) unitMap\n Just . Token Distance $ withUnit x dd\n _ -> Nothing\n }\n\nruleLatentDistDeUnit :: Rule\nruleLatentDistDeUnit = Rule\n { name = \" foot/inch/yard/meter/kilometer/centimeter\"\n , pattern =\n [ dimension Distance\n , regex \"de (inc(hi?|i)|(centi|kilo)?metr[iu]|mil[ea\u00c4\u0192]|[ck]?m|picio(are|r)|y(ar)?(zi|d)?)\"\n ]\n , prod = \\case\n (Token Distance dd:\n Token RegexMatch (GroupMatch (match:_)):\n _) -> do\n x <- HashMap.lookup (Text.toLower match) unitMap\n Just . Token Distance $ withUnit x dd\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleLatentDistUnit\n , ruleLatentDistDeUnit\n ]\n", "num_lines": 93} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Distance.SV.Corpus\n ( corpus\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Distance.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale SV Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple Kilometre 3)\n [ \"3 kilometer\"\n , \"3 km\"\n , \"3km\"\n , \"3k\"\n ]\n , examples (simple Kilometre 30)\n [ \"3 mil\"\n , \"tre mil\"\n , \"n\u00c3\u00a5gra f\u00c3\u00a5 mil\"\n ]\n , examples (simple Kilometre 3.0)\n [ \"3,0 km\"\n ]\n , examples (simple Metre 9)\n [ \"9 meter\"\n , \"9m\"\n ]\n , examples (simple Centimetre 2)\n [ \"2cm\"\n , \"2 centimeter\"\n ]\n ]\n", "num_lines": 50} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Distance.SV.Rules\n ( rules\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Dimensions.Types\nimport Duckling.Distance.Helpers\nimport Duckling.Distance.Types (DistanceData(..))\nimport Duckling.Types\nimport qualified Duckling.Distance.Types as TDistance\n\nruleLatentDistKm :: Rule\nruleLatentDistKm = Rule\n { name = \" km\"\n , pattern =\n [ dimension Distance\n , regex \"k(ilo)?m?(eter)?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just . Token Distance $ withUnit TDistance.Kilometre dd\n _ -> Nothing\n }\n\nruleDistMeters :: Rule\nruleDistMeters = Rule\n { name = \" meter\"\n , pattern =\n [ dimension Distance\n , regex \"m(eter)?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just . Token Distance $ withUnit TDistance.Metre dd\n _ -> Nothing\n }\n\nruleDistCentimeters :: Rule\nruleDistCentimeters = Rule\n { name = \" centimeters\"\n , pattern =\n [ dimension Distance\n , regex \"cm|centimeter\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just . Token Distance $ withUnit TDistance.Centimetre dd\n _ -> Nothing\n }\n\nruleDistMils :: Rule\nruleDistMils = Rule\n { name = \" mils\"\n , pattern =\n [ dimension Distance\n , regex \"mils?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd@DistanceData {TDistance.value = Just x}:_) ->\n Just . Token Distance . withValue (10 * x)\n $ withUnit TDistance.Kilometre dd\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleDistCentimeters\n , ruleDistMeters\n , ruleDistMils\n , ruleLatentDistKm\n ]\n", "num_lines": 84} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Distance.TR.Corpus\n ( corpus ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Distance.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale TR Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple Kilometre 3)\n [ \"3 Kilometre\"\n , \"3 kilometre\"\n , \"3 km\"\n , \"3km\"\n ]\n , examples (simple Kilometre 3.0)\n [ \"3,0 km\"\n ]\n , examples (simple Mile 8)\n [ \"8 Mil\"\n , \"8 mil\"\n ]\n , examples (simple Metre 9)\n [ \"9 Metre\"\n , \"9 metre\"\n , \"9 m\"\n , \"9m\"\n ]\n , examples (simple Centimetre 2)\n [ \"2 Santimetre\"\n , \"2 santim\"\n , \"2 cm\"\n , \"2cm\"\n ]\n ]\n", "num_lines": 52} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Distance.TR.Rules\n ( rules ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Dimensions.Types\nimport Duckling.Distance.Helpers\nimport qualified Duckling.Distance.Types as TDistance\nimport Duckling.Types\n\nruleLatentDistKm :: Rule\nruleLatentDistKm = Rule\n { name = \" km\"\n , pattern =\n [ dimension Distance\n , regex \"k(ilo)?m?(etre)?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just . Token Distance $ withUnit TDistance.Kilometre dd\n _ -> Nothing\n }\n\nruleDistMeters :: Rule\nruleDistMeters = Rule\n { name = \" meters\"\n , pattern =\n [ dimension Distance\n , regex \"m(etre)?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just . Token Distance $ withUnit TDistance.Metre dd\n _ -> Nothing\n }\n\nruleDistCentimeters :: Rule\nruleDistCentimeters = Rule\n { name = \" centimeters\"\n , pattern =\n [ dimension Distance\n , regex \"cm|santim(etre)?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just . Token Distance $ withUnit TDistance.Centimetre dd\n _ -> Nothing\n }\n\nruleDistMiles :: Rule\nruleDistMiles = Rule\n { name = \" miles\"\n , pattern =\n [ dimension Distance\n , regex \"mil\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Distance dd:_) ->\n Just . Token Distance $ withUnit TDistance.Mile dd\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleDistCentimeters\n , ruleDistMeters\n , ruleDistMiles\n , ruleLatentDistKm\n ]\n", "num_lines": 81} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n-- | This module shadows names of some units previously defined in\n-- 'Duckling.Distance.Types'.\n-- Therefore, the units from that module must be used qualified by module.\nmodule Duckling.DistanceUnits.Types\n ( ContextualDistance (..)\n , toSystemUnit\n , toRawUnit\n ) where\n\nimport Data.Semigroup\nimport Data.Tuple.Extra (both)\nimport Prelude\n\nimport qualified Duckling.Distance.Types as TDist\n\n\n-- | Supports deferred resolution of ambiguous units.\n-- Note that this sum type cannot be simply replaced by\n-- \"Maybe (ContextualDistance Double DeferrableUnit)\"\n-- (with \"Nothing\" representing \"Nonrelatable\").\n-- See \"NOTE A\" below.\ndata ContextualDistance\n = Nonrelatable\n -- ^ If two different ambiguous units were to be composed, then\n -- it would not be possible to decide which to resolve to. As of today,\n -- this won't happen since for now \"M\" is the lone ambiguous unit.\n | ContextualDistance Double DeferrableUnit\n\n-- | This represents Units that have not yet been established as unrelatable.\n-- The \"Definite\" constructor is purposely listed in front of \"Ambiguous\",\n-- so that it will be preferred when taking choosing the \"min\" between\n-- an \"Ambiguous\" and \"Definite\" unit.\ndata DeferrableUnit\n = Definite SystemUnit\n | Ambiguous AmbiguousUnit\n deriving (Eq, Ord)\n\n-- | These measurement-system-specific units exist to disambiguate\n-- the \\\"M\\\" of the 'Unit' type and to maintain the measurement-system context\n-- for resolving to the appropriate precision.\n--\n-- It's also just handy to have separate programmatically accessible lists\n-- of units for each type of measurement system.\ndata SystemUnit\n = Metric MetricUnit\n | Imperial ImperialUnit\n deriving (Eq, Ord)\n\ndata ImperialUnit\n = Inch\n | Foot\n | Yard\n | Mile\n deriving (Eq, Ord)\n\ndata MetricUnit\n = Millimetre\n | Centimetre\n | Metre\n | Kilometre\n deriving (Eq, Ord)\n\n-- | Currently there is only one actually ambiguous unit, but this design allows\n-- for expansion.\ndata AmbiguousUnit\n = M -- ^ \"Miles\" or \"Metres\"\n deriving (Eq, Ord)\n\n-- | Represents a value with an unambiguous unit\ndata UnitValuePair = UnitValuePair SystemUnit Double\n\nsumScaledUnits :: SystemUnit -> (UnitValuePair, UnitValuePair) -> Double\nsumScaledUnits preferredUnit = uncurry (+) . both (scaleUnits preferredUnit)\n\n-- | Determine the definite meaning of an \"Ambiguous\" unit using the context of\n-- another \"Definite\" unit\nreconcileAmbiguousWithDefinite ::\n Double\n -> AmbiguousUnit\n -> Double\n -> SystemUnit\n -> ContextualDistance\nreconcileAmbiguousWithDefinite av au dv du =\n ContextualDistance combinedValue $ Definite preferredUnit\n where\n resolvedAmbiguousUnit = resolveUnit au du\n preferredUnit = du `min` resolvedAmbiguousUnit\n combinedValue = sumScaledUnits preferredUnit\n (UnitValuePair resolvedAmbiguousUnit av, UnitValuePair du dv)\n\n-- | When both Metric and Imperial units are given, resolve to Metric.\n-- Otherwise, preserve the original measurement system and use the smaller unit.\n-- For the purpose of this resolution, all Metric units are considered \"smaller\"\n-- than Imperial units.\ninstance Semigroup ContextualDistance where\n\n _ <> Nonrelatable = Nonrelatable\n Nonrelatable <> _ = Nonrelatable\n\n (ContextualDistance v1 u@(Ambiguous u1))\n <> (ContextualDistance v2 (Ambiguous u2))\n | u1 == u2 = ContextualDistance (v1 + v2) u\n | otherwise = Nonrelatable\n -- NOTE A: Needing to return \"Nonrelatable\" in this edge case is why\n -- the two-member \"ContextualDistance\" sum type cannot be simply\n -- represented as (Maybe (ContextualDistance Double DeferrableUnit)).\n\n (ContextualDistance av (Ambiguous au))\n <> (ContextualDistance dv (Definite du)) =\n reconcileAmbiguousWithDefinite av au dv du\n\n (ContextualDistance dv (Definite du))\n <> (ContextualDistance av (Ambiguous au)) =\n reconcileAmbiguousWithDefinite av au dv du\n\n (ContextualDistance v1 (Definite u1))\n <> (ContextualDistance v2 (Definite u2)) =\n ContextualDistance v $ Definite u\n where\n v = sumScaledUnits u (UnitValuePair u1 v1, UnitValuePair u2 v2)\n u = u1 `min` u2\n\nresolveUnit :: AmbiguousUnit -> SystemUnit -> SystemUnit\nresolveUnit M (Metric _) = Metric Metre\nresolveUnit M (Imperial _) = Imperial Mile\n\n\n-- | Disambiguation of original Unit type\ntoSystemUnit :: TDist.Unit -> DeferrableUnit\ntoSystemUnit TDist.M = Ambiguous M\ntoSystemUnit TDist.Millimetre = Definite $ Metric Millimetre\ntoSystemUnit TDist.Centimetre = Definite $ Metric Centimetre\ntoSystemUnit TDist.Metre = Definite $ Metric Metre\ntoSystemUnit TDist.Kilometre = Definite $ Metric Kilometre\ntoSystemUnit TDist.Inch = Definite $ Imperial Inch\ntoSystemUnit TDist.Foot = Definite $ Imperial Foot\ntoSystemUnit TDist.Yard = Definite $ Imperial Yard\ntoSystemUnit TDist.Mile = Definite $ Imperial Mile\n\n-- | Reconversion to original Unit type\ntoRawUnit :: DeferrableUnit -> TDist.Unit\ntoRawUnit (Ambiguous M) = TDist.M\ntoRawUnit (Definite (Metric Millimetre)) = TDist.Millimetre\ntoRawUnit (Definite (Metric Centimetre)) = TDist.Centimetre\ntoRawUnit (Definite (Metric Metre)) = TDist.Metre\ntoRawUnit (Definite (Metric Kilometre)) = TDist.Kilometre\ntoRawUnit (Definite (Imperial Inch)) = TDist.Inch\ntoRawUnit (Definite (Imperial Foot)) = TDist.Foot\ntoRawUnit (Definite (Imperial Yard)) = TDist.Yard\ntoRawUnit (Definite (Imperial Mile)) = TDist.Mile\n\n-- | Convert a distance to the given units.\n-- This only works if the unit is unambiguous.\nscaleUnits ::\n SystemUnit -- ^ target unit\n -> UnitValuePair -- ^ Original unit and value\n -> Double\nscaleUnits targetUnit (UnitValuePair startingUnit v)\n | startingUnit == targetUnit = v\n | otherwise = inSIUnits v startingUnit / inSIUnits 1 targetUnit\n\n-- | This is used when distances\n-- must be normalized across measurement systems.\n-- The Metric metre is the Standard International unit of distance.\ninSIUnits :: Double -> SystemUnit -> Double\ninSIUnits val (Metric u) = inMetres u val\ninSIUnits val (Imperial u) = inInches u val * metersPerInch\n\n-- | This conversion factor is exact.\nmetersPerInch :: Double\nmetersPerInch = 0.0254\n\ninMetres :: Fractional a => MetricUnit -> a -> a\ninMetres Millimetre n = n / 1000\ninMetres Centimetre n = n / 100\ninMetres Metre n = n\ninMetres Kilometre n = n * 1000\n\ninInches :: Num a => ImperialUnit -> a -> a\ninInches Inch n = n\ninInches Foot n = 12 * n\ninInches Yard n = 3 * inInches Foot n\ninInches Mile n = 5280 * inInches Foot n\n", "num_lines": 191} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n\nmodule Duckling.Duration.Helpers\n ( duration\n , isGrain\n , isNatural\n , minutesFromHourMixedFraction\n , nPlusOneHalf\n , secondsFromHourMixedFraction\n , timesOneQuarter\n , timesThreeQuarter\n , inCoarsestGrain\n ) where\n\nimport Prelude\n\nimport Duckling.Dimensions.Types\nimport Duckling.Duration.Types (DurationData (DurationData))\nimport Duckling.Numeral.Helpers (isNatural)\nimport Duckling.Types\nimport qualified Duckling.Duration.Types as TDuration\nimport qualified Duckling.Numeral.Types as TNumeral\nimport qualified Duckling.TimeGrain.Types as TG\n\n-- -----------------------------------------------------------------\n-- Patterns\n\nisGrain :: TG.Grain -> Predicate\nisGrain value (Token TimeGrain grain) = grain == value\nisGrain _ _ = False\n\n-- -----------------------------------------------------------------\n-- Production\n\nduration :: TG.Grain -> Int -> DurationData\nduration grain n = DurationData {TDuration.grain = grain, TDuration.value = n}\n\nminutesFromHourMixedFraction :: Integer -> Integer -> Integer -> DurationData\nminutesFromHourMixedFraction h n d =\n duration TG.Minute $ fromIntegral $ 60 * h + quot (n * 60) d\n\nnPlusOneHalf :: TG.Grain -> Int -> Maybe DurationData\nnPlusOneHalf grain = case grain of\n TG.Minute -> Just . duration TG.Second . (30+) . (60*)\n TG.Hour -> Just . duration TG.Minute . (30+) . (60*)\n TG.Day -> Just . duration TG.Hour . (12+) . (24*)\n TG.Month -> Just . duration TG.Day . (15+) . (30*)\n TG.Year -> Just . duration TG.Month . (6+) . (12*)\n _ -> const Nothing\n\nsecondsFromHourMixedFraction :: Integer -> Integer -> Integer -> DurationData\nsecondsFromHourMixedFraction m s d =\n duration TG.Second $ fromIntegral $ 60 * m + quot (s * 60) d\n\ntimesOneQuarter :: TG.Grain -> Int -> Maybe DurationData\ntimesOneQuarter grain = case grain of\n TG.Minute -> Just . duration TG.Second . (15+) . (60*)\n TG.Hour -> Just . duration TG.Minute . (15+) . (60*)\n TG.Day -> Just . duration TG.Hour . (6+) . (24*)\n TG.Month -> Just . duration TG.Day . (7+) . (30*)\n TG.Year -> Just . duration TG.Month . (3+) . (12*)\n _ -> const Nothing\n\ntimesThreeQuarter :: TG.Grain -> Int -> Maybe DurationData\ntimesThreeQuarter grain = case grain of\n TG.Minute -> Just . duration TG.Second . (45+) . (60*)\n TG.Hour -> Just . duration TG.Minute . (45+) . (60*)\n TG.Day -> Just . duration TG.Hour . (18+) . (24*)\n TG.Month -> Just . duration TG.Day . (21+) . (30*)\n TG.Year -> Just . duration TG.Month . (9+) . (12*)\n _ -> const Nothing\n\ninCoarsestGrain :: TG.Grain -> Double -> DurationData\ninCoarsestGrain g v =\n go g\n where\n seconds = fromIntegral (floor $ TG.inSeconds g v :: Int)\n go grain =\n -- recursion terminates because `seconds` is an Integer\n let inGrain = seconds / TG.inSeconds grain 1\n in case TNumeral.getIntValue inGrain of\n Just n -> duration grain n\n Nothing -> go $ TG.lower grain\n", "num_lines": 91} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Duration.Rules\n ( rules\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Dimensions.Types\nimport Duckling.Duration.Helpers\nimport Duckling.Numeral.Types (NumeralData(..))\nimport Duckling.Types\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleIntegerUnitofduration :: Rule\nruleIntegerUnitofduration = Rule\n { name = \" \"\n , pattern =\n [ Predicate isNatural\n , dimension TimeGrain\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = v}:\n Token TimeGrain grain:\n _) -> Just . Token Duration . duration grain $ floor v\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleIntegerUnitofduration\n ]\n", "num_lines": 43} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE DeriveAnyClass #-}\n{-# LANGUAGE DeriveGeneric #-}\n{-# LANGUAGE NamedFieldPuns #-}\n{-# LANGUAGE NoRebindableSyntax #-}\n{-# LANGUAGE OverloadedStrings #-}\n{-# LANGUAGE TypeFamilies #-}\n\nmodule Duckling.Duration.Types where\n\nimport Control.DeepSeq\nimport Data.Aeson\nimport Data.Hashable\nimport Data.Semigroup\nimport Data.Text (Text)\nimport Data.Tuple.Extra (both)\nimport GHC.Generics\nimport TextShow (showt)\nimport Prelude\n\nimport Duckling.Resolve (Resolve(..))\nimport Duckling.TimeGrain.Types (Grain(..), inSeconds)\n\ndata DurationData = DurationData\n { value :: Int\n , grain :: Grain\n }\n deriving (Eq, Generic, Hashable, Show, Ord, NFData)\n\ninstance Resolve DurationData where\n type ResolvedValue DurationData = DurationData\n resolve _ _ x = Just (x, False)\n\ninstance Semigroup DurationData where\n d1@(DurationData _ g1) <> d2@(DurationData _ g2) = DurationData (v1+v2) g\n where\n g = g1 `min` g2\n (DurationData v1 _, DurationData v2 _) = both (withGrain g) (d1,d2)\n\ninstance ToJSON DurationData where\n toJSON DurationData {value, grain} = object\n [ \"type\" .= (\"value\" :: Text)\n , \"value\" .= value\n , \"unit\" .= grain\n , showt grain .= value\n , \"normalized\" .= object\n [ \"unit\" .= (\"second\" :: Text)\n , \"value\" .= inSeconds grain value\n ]\n ]\n\n-- | Convert a duration to the given grain, rounded to the\n-- nearest integer. For example, 1 month is converted to 4 weeks.\nwithGrain :: Grain -> DurationData -> DurationData\nwithGrain g d@(DurationData v1 g1)\n | g == g1 = d\n | otherwise = DurationData v g\n where\n v = round $ inSeconds g1 (fromIntegral v1 :: Double) / inSeconds g 1\n", "num_lines": 66} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Duration.AR.Corpus\n ( corpus\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Duration.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Testing.Types\nimport Duckling.TimeGrain.Types (Grain(..))\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale AR Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (DurationData 1 Second)\n [ \"\u00d8\u00ab\u00d8\u00a7\u00d9\u2020\u00d9\u0160\u00d8\u00a9\"\n , \"\u00d9\u201e\u00d8\u00ad\u00d8\u00b8\u00d8\u00a9\"\n ]\n , examples (DurationData 2 Minute)\n [ \"\u00d8\u00af\u00d9\u201a\u00d9\u0160\u00d9\u201a\u00d8\u00aa\u00d8\u00a7\u00d9\u2020\"\n , \"\u00d8\u00af\u00d9\u201a\u00d9\u0160\u00d9\u201a\u00d8\u00aa\u00d9\u0160\u00d9\u2020\"\n ]\n , examples (DurationData 5 Hour)\n [ \"\u00d8\u00ae\u00d9\u2026\u00d8\u00b3\u00d8\u00a9 \u00d8\u00b3\u00d8\u00a7\u00d8\u00b9\u00d8\u00a7\u00d8\u00aa\"\n ]\n , examples (DurationData 30 Day)\n [ \"30 \u00d9\u0160\u00d9\u02c6\u00d9\u2026\"\n ]\n , examples (DurationData 1 Week)\n [ \"\u00d8\u00a7\u00d8\u00b3\u00d8\u00a8\u00d9\u02c6\u00d8\u00b9\"\n ]\n , examples (DurationData 7 Week)\n [ \"\u00d8\u00b3\u00d8\u00a8\u00d8\u00b9 \u00d8\u00a7\u00d8\u00b3\u00d8\u00a7\u00d8\u00a8\u00d9\u0160\u00d8\u00b9\"\n ]\n , examples (DurationData 1 Month)\n [ \"\u00d8\u00b4\u00d9\u2021\u00d8\u00b1\"\n ]\n , examples (DurationData 2 Month)\n [ \"\u00d8\u00b4\u00d9\u2021\u00d8\u00b1\u00d9\u0160\u00d9\u2020\"\n ]\n , examples (DurationData 2 Year)\n [ \"\u00d8\u00b3\u00d9\u2020\u00d8\u00aa\u00d9\u0160\u00d9\u2020\"\n , \"\u00d8\u00b3\u00d9\u2020\u00d8\u00aa\u00d8\u00a7\u00d9\u2020\"\n , \"\u00d8\u00b9\u00d8\u00a7\u00d9\u2026\u00d9\u0160\u00d9\u2020\"\n , \"\u00d8\u00b9\u00d8\u00a7\u00d9\u2026\u00d8\u00a7\u00d9\u2020\"\n ]\n ]\n", "num_lines": 61} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Duration.CA.Corpus\n ( corpus\n ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Duration.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Testing.Types\nimport Duckling.TimeGrain.Types (Grain(..))\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale CA Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (DurationData 30 Minute)\n [ \"mitja hora\"\n , \"dos quarts\"\n , \"30 minuts\"\n , \"trenta minuts\"\n ]\n , examples (DurationData 15 Minute)\n [ \"quart d'hora\"\n , \"un quart d'hora\"\n , \"1 quart d'hora\"\n , \"1/4 d'hora\"\n , \"quinze minuts\"\n , \"15 minuts\"\n ]\n , examples (DurationData 45 Minute)\n [ \"tres quarts d'hora\"\n , \"3/4 d'hora\"\n , \"3 quarts d'hora\"\n , \"tres quarts\"\n , \"quaranta-cinc minuts\"\n , \"45 minuts\"\n ]\n , examples (DurationData 92 Minute)\n [ \"una hora i trenta-dos minuts\"\n , \"una hora trenta-dos minuts\"\n ]\n , examples (DurationData 155 Minute)\n [ \"dues hores i trenta-cinc minuts\"\n , \"dues hores trenta-cinc minuts\"\n ]\n ]\n", "num_lines": 59} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE NoRebindableSyntax #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Duration.CA.Rules\n ( rules\n ) where\n\nimport Prelude\nimport Duckling.Dimensions.Types\nimport Duckling.Duration.Helpers\nimport Duckling.Duration.Types (DurationData(..))\nimport Duckling.Numeral.Types (NumeralData(..))\nimport Duckling.Types\nimport qualified Duckling.Duration.Types as TDuration\nimport qualified Duckling.Numeral.Types as TNumeral\nimport qualified Duckling.TimeGrain.Types as TG\n\nruleDurationQuarterOfAnHour :: Rule\nruleDurationQuarterOfAnHour = Rule\n { name = \"quarter of an hour\"\n , pattern =\n [ regex \"((1 |un )?quarts?|1/4) d'hora\"\n ]\n , prod = \\_ -> Just $ Token Duration $ duration TG.Minute 15\n }\n\nruleDurationHalfOfAnHour :: Rule\nruleDurationHalfOfAnHour = Rule\n { name = \"half of an hour\"\n , pattern =\n [ regex \"(mitja hora|dos quarts)\"\n ]\n , prod = \\_ -> Just $ Token Duration $ duration TG.Minute 30\n }\n\nruleDurationThreeQuartersOfAnHour :: Rule\nruleDurationThreeQuartersOfAnHour = Rule\n { name = \"three-quarters of an hour\"\n , pattern =\n [ regex \"((tres|3) quarts|3/4)( d'hor([a]|(es)))?\"\n ]\n , prod = \\_ -> Just $ Token Duration $ duration TG.Minute 45\n }\n\nruleCompositeDurationCommasAnd :: Rule\nruleCompositeDurationCommasAnd = Rule\n { name = \"composite (with and)\"\n , pattern =\n [ Predicate isNatural\n , dimension TimeGrain\n , regex \"i\"\n , dimension Duration\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = v}:\n Token TimeGrain g:\n _:\n Token Duration dd@DurationData{TDuration.grain = dg}:\n _) | g > dg -> Just $ Token Duration $ duration g (floor v) <> dd\n _ -> Nothing\n }\n\nruleCompositeDuration :: Rule\nruleCompositeDuration = Rule\n {\n name = \"composite \"\n , pattern =\n [\n Predicate isNatural\n , dimension TimeGrain\n , dimension Duration\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = v}:\n Token TimeGrain g:\n Token Duration dd@DurationData{TDuration.grain = dg}:\n _) | g > dg -> Just $ Token Duration $ duration g (floor v) <> dd\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleDurationHalfOfAnHour\n , ruleDurationQuarterOfAnHour\n , ruleDurationThreeQuartersOfAnHour\n , ruleCompositeDuration\n , ruleCompositeDurationCommasAnd\n ]\n", "num_lines": 98} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Duration.DA.Rules\n ( rules ) where\n\nimport Control.Monad (join)\nimport qualified Data.Text as Text\nimport Prelude\nimport Data.String\n\nimport Duckling.Dimensions.Types\nimport Duckling.Duration.Helpers\nimport Duckling.Numeral.Helpers (parseInteger)\nimport Duckling.Numeral.Types (NumeralData (..))\nimport qualified Duckling.Numeral.Types as TNumeral\nimport Duckling.Regex.Types\nimport qualified Duckling.TimeGrain.Types as TG\nimport Duckling.Types\n\nruleExactlyDuration :: Rule\nruleExactlyDuration = Rule\n { name = \"exactly \"\n , pattern =\n [ regex \"pr(\u00c3\u00a6)cis\"\n , dimension Duration\n ]\n , prod = \\tokens -> case tokens of\n -- TODO(jodent) +precision exact\n (_:token:_) -> Just token\n _ -> Nothing\n }\n\nruleIntegerAndAnHalfHours :: Rule\nruleIntegerAndAnHalfHours = Rule\n { name = \" and an half hours\"\n , pattern =\n [ Predicate isNatural\n , regex \"og (en )?halv timer?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v}:_) ->\n Just . Token Duration . duration TG.Minute $ 30 + 60 * floor v\n _ -> Nothing\n }\n\nruleAUnitofduration :: Rule\nruleAUnitofduration = Rule\n { name = \"a \"\n , pattern =\n [ regex \"en|et?\"\n , dimension TimeGrain\n ]\n , prod = \\tokens -> case tokens of\n (_:Token TimeGrain grain:_) -> Just . Token Duration $ duration grain 1\n _ -> Nothing\n }\n\nruleIntegerMoreUnitofduration :: Rule\nruleIntegerMoreUnitofduration = Rule\n { name = \" more \"\n , pattern =\n [ Predicate isNatural\n , dimension TimeGrain\n , regex \"mere|mindre\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v}:\n Token TimeGrain grain:\n _) -> Just . Token Duration . duration grain $ floor v\n _ -> Nothing\n }\n\nruleFortnight :: Rule\nruleFortnight = Rule\n { name = \"fortnight\"\n , pattern =\n [ regex \"(a|one)? fortnight\"\n ]\n , prod = \\_ -> Just . Token Duration $ duration TG.Day 14\n }\n\nruleAboutDuration :: Rule\nruleAboutDuration = Rule\n { name = \"about \"\n , pattern =\n [ regex \"(omkring|cirka|ca.)\"\n , dimension Duration\n ]\n , prod = \\tokens -> case tokens of\n -- TODO(jodent) +precision approximate\n (_:token:_) -> Just token\n _ -> Nothing\n }\n\nruleNumeralnumberHours :: Rule\nruleNumeralnumberHours = Rule\n { name = \"number.number hours\"\n , pattern =\n [ regex \"(\\\\d+)\\\\,(\\\\d+)\"\n , regex \"timer?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (h:m:_)):_) -> do\n hh <- parseInteger h\n mnum <- parseInteger m\n let mden = 10 ^ Text.length m\n Just . Token Duration $ minutesFromHourMixedFraction hh mnum mden\n _ -> Nothing\n }\n\nruleHalfAnHour :: Rule\nruleHalfAnHour = Rule\n { name = \"half an hour\"\n , pattern =\n [ regex \"(1/2|en halv) time\"\n ]\n , prod = \\_ -> Just . Token Duration $ duration TG.Minute 30\n }\n\nrules :: [Rule]\nrules =\n [ ruleAUnitofduration\n , ruleAboutDuration\n , ruleExactlyDuration\n , ruleFortnight\n , ruleHalfAnHour\n , ruleIntegerAndAnHalfHours\n , ruleIntegerMoreUnitofduration\n , ruleNumeralnumberHours\n ]\n", "num_lines": 139} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Duration.DE.Corpus\n ( corpus\n ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Duration.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Testing.Types\nimport Duckling.TimeGrain.Types (Grain(..))\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale DE Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (DurationData 1 Second)\n [ \"ein sekunde\"\n , \"zirka eine sekunde\"\n ]\n , examples (DurationData 30 Minute)\n [ \"1/2 stunde\"\n , \"1/2stunde\"\n , \"eine halbe stunde\"\n , \"einer halben stunde\"\n , \"halbe stunde\"\n , \"halben stunde\"\n , \"ungefahr einer halben stunde\"\n ]\n , examples (DurationData 15 Minute)\n [ \"einer Viertelstunde\"\n , \"eine viertelstunde\"\n , \"ViErTelStUnDe\"\n , \"genau viertelstunde\"\n ]\n , examples (DurationData 45 Minute)\n [ \"3/4 stunde\"\n , \"3/4stunde\"\n , \"eine dreiviertel stunde\"\n , \"einer dreiviertel stunde\"\n , \"dreiviertel stunde\"\n , \"drei viertelstunden\"\n ]\n , examples (DurationData 92 Minute)\n [ \"92 minuten\"\n , \"zweiundneunzig minuten\"\n , \"eine Stunde und zweiunddrei\u00c3\u0178ig Minuten\"\n , \"ein stunde und zweiunddreissig minuten\"\n ]\n , examples (DurationData 30 Day)\n [ \"30 tage\"\n , \"drei\u00c3\u0178ig tage\"\n , \"dreissig tage\"\n ]\n , examples (DurationData 7 Week)\n [ \"7 Wochen\"\n , \"sieben wochen\"\n ]\n , examples (DurationData 90 Minute)\n [ \"1,5 stunden\"\n , \"1,5 stunde\"\n , \"90 min\"\n , \"90min\"\n ]\n , examples (DurationData 75 Minute)\n [ \"1,25 stunden\"\n ]\n , examples (DurationData 31719604 Second)\n [ \"1 Jahr, 2 Tage, 3 Stunden und 4 Sekunden\"\n , \"1 Jahr 2 Tage 3 Stunden und 4 Sekunden\"\n ]\n , examples (DurationData 330 Second)\n [ \"5 und eine halbe Minuten\"\n , \"5,5 min\"\n ]\n , examples (DurationData 330 Minute)\n [ \"5 und eine halbe stunden\"\n , \"5,5 stunde\"\n , \"exakt 5,5 stunden\"\n ]\n , examples (DurationData 930 Second)\n [ \"15,5 minuten\"\n , \"15,5 minute\"\n , \"15,5 min\"\n ]\n ]\n", "num_lines": 98} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Duration.DE.Rules\n ( rules ) where\n\n\nimport Duckling.Dimensions.Types\nimport Duckling.Duration.Helpers\nimport Duckling.Regex.Types\nimport Control.Monad (join)\nimport qualified Data.Text as Text\nimport Prelude\nimport Duckling.Numeral.Helpers (numberBetween, parseInteger)\nimport Duckling.Duration.Types (DurationData(..))\nimport qualified Duckling.Duration.Types as TDuration\nimport Data.String\nimport Duckling.Numeral.Types (NumeralData(..))\nimport qualified Duckling.TimeGrain.Types as TG\nimport qualified Duckling.Numeral.Types as TNumeral\nimport Duckling.Types\n\nruleQuarterOfAnHour :: Rule\nruleQuarterOfAnHour = Rule\n { name = \"quarter of an hour\"\n , pattern =\n [ regex \"(einer? )?Viertelstunde\"\n ]\n , prod = \\_ -> Just $ Token Duration $ duration TG.Minute 15\n }\n\nruleHalfAnHour :: Rule\nruleHalfAnHour = Rule\n { name = \"half an hour\"\n , pattern =\n [ regex \"(1/2\\\\s?|(eine )?halbe |(einer )?halben )stunde\"\n ]\n , prod = \\_ -> Just $ Token Duration $ duration TG.Minute 30\n }\n\nruleThreeQuartersOfAnHour :: Rule\nruleThreeQuartersOfAnHour = Rule\n { name = \"three-quarters of an hour\"\n , pattern =\n [ regex \"3/4\\\\s?stunde|(einer? )?dreiviertel stunde|drei viertelstunden\"\n ]\n , prod = \\_ -> Just $ Token Duration $ duration TG.Minute 45\n }\n\nruleFortnight :: Rule\nruleFortnight = Rule\n { name = \"fortnight\"\n , pattern =\n [ regex \"zwei Wochen\"\n ]\n , prod = \\_ -> Just $ Token Duration $ duration TG.Day 14\n }\n\nrulePrecision :: Rule\nrulePrecision = Rule\n { name = \"about|exactly \"\n , pattern =\n [ regex \"ungef(\u00c3\u00a4|a)hr|zirka|genau|exakt\"\n , dimension Duration\n ]\n , prod = \\case\n (_:token:_) -> Just token\n _ -> Nothing\n }\n\nruleCommaNumeralHours :: Rule\nruleCommaNumeralHours = Rule\n { name = \"number,number hours\"\n , pattern =\n [ regex \"(\\\\d+),(\\\\d+)\"\n , Predicate $ isGrain TG.Hour\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (h:m:_)):_) -> do\n hh <- parseInteger h\n mnum <- parseInteger m\n let mden = 10 ^ Text.length m\n Just $ Token Duration $ minutesFromHourMixedFraction hh mnum mden\n _ -> Nothing\n }\n\nruleCommaNumeralMinutes :: Rule\nruleCommaNumeralMinutes = Rule\n { name = \"number,number minutes\"\n , pattern =\n [ regex \"(\\\\d+),(\\\\d+)\"\n , Predicate $ isGrain TG.Minute\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (m:s:_)):_) -> do\n mm <- parseInteger m\n ss <- parseInteger s\n let sden = 10 ^ Text.length s\n Just $ Token Duration $ secondsFromHourMixedFraction mm ss sden\n _ -> Nothing\n }\n\nruleAndHalfHour :: Rule\nruleAndHalfHour = Rule\n { name = \" and a half hour\"\n , pattern =\n [ Predicate isNatural\n , regex \"(und )?(ein(en?)? )?halb(en?)?\"\n , Predicate $ isGrain TG.Hour\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = v}:_) ->\n Just $ Token Duration $ duration TG.Minute $ 30 + 60 * floor v\n _ -> Nothing\n }\n\nruleAndHalfMinute :: Rule\nruleAndHalfMinute = Rule\n { name = \" and a half minutes\"\n , pattern =\n [ Predicate isNatural\n , regex \"(und )?(ein(en?)? ?)?halb(en?)?\"\n , Predicate $ isGrain TG.Minute\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = v}:_) ->\n Just $ Token Duration $ duration TG.Second $ 30 + 60 * floor v\n _ -> Nothing\n }\n\nruleArticle :: Rule\nruleArticle = Rule\n { name = \"a \"\n , pattern =\n [ regex \"ein(en?)?\"\n , dimension TimeGrain\n ]\n , prod = \\case\n (_:Token TimeGrain grain:_) -> Just $ Token Duration $ duration grain 1\n _ -> Nothing\n }\n\nruleHalfTimeGrain :: Rule\nruleHalfTimeGrain = Rule\n { name = \"half a \"\n , pattern =\n [ regex \"(ein(en)?)?(1/2|halbe?)\"\n , dimension TimeGrain\n ]\n , prod = \\case\n (_:Token TimeGrain grain:_) -> Token Duration <$> nPlusOneHalf grain 0\n _ -> Nothing\n }\n\nruleCompositeDurationCommasAnd :: Rule\nruleCompositeDurationCommasAnd = Rule\n { name = \"composite (with ,/and)\"\n , pattern =\n [ Predicate isNatural\n , dimension TimeGrain\n , regex \",|und\"\n , dimension Duration\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = v}:\n Token TimeGrain g:\n _:\n Token Duration dd@DurationData{TDuration.grain = dg}:\n _) | g > dg -> Just $ Token Duration $ duration g (floor v) <> dd\n _ -> Nothing\n }\n\nruleCompositeDuration :: Rule\nruleCompositeDuration = Rule\n { name = \"composite \"\n , pattern =\n [ Predicate isNatural\n , dimension TimeGrain\n , dimension Duration\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = v}:\n Token TimeGrain g:\n Token Duration dd@DurationData{TDuration.grain = dg}:\n _) | g > dg -> Just $ Token Duration $ duration g (floor v) <> dd\n _ -> Nothing\n }\n\nruleCompositeDurationAnd :: Rule\nruleCompositeDurationAnd = Rule\n { name = \"composite and \"\n , pattern =\n [ dimension Duration\n , regex \",|und\"\n , dimension Duration\n ]\n , prod = \\case\n (Token Duration DurationData{TDuration.value = v, TDuration.grain = g}:\n _:\n Token Duration dd@DurationData{TDuration.grain = dg}:\n _) | g > dg -> Just $ Token Duration $ duration g v <> dd\n _ -> Nothing\n }\n\nruleHoursAndMinutes :: Rule\nruleHoursAndMinutes = Rule\n { name = \" hour and \"\n , pattern =\n [ Predicate isNatural\n , regex \"(ein(en?) )?stunden?( und)?\"\n , Predicate $ and . sequence [isNatural, numberBetween 1 60]\n , Predicate $ isGrain TG.Minute\n ]\n , prod = \\case\n (Token Numeral h:\n _:\n Token Numeral m:\n _) -> Just $ Token Duration $ duration TG.Minute $\n floor (TNumeral.value m) + 60 * floor (TNumeral.value h)\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleQuarterOfAnHour\n , ruleHalfAnHour\n , ruleThreeQuartersOfAnHour\n , rulePrecision\n , ruleCommaNumeralHours\n , ruleCommaNumeralMinutes\n , ruleFortnight\n , ruleAndHalfHour\n , ruleAndHalfMinute\n , ruleArticle\n , ruleHalfTimeGrain\n , ruleCompositeDurationCommasAnd\n , ruleCompositeDuration\n , ruleCompositeDurationAnd\n , ruleHoursAndMinutes\n , ruleAndHalfMinute\n ]\n", "num_lines": 250} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Duration.EN.Corpus\n ( corpus\n , negativeCorpus\n ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Duration.Types\nimport Duckling.Testing.Types\nimport Duckling.TimeGrain.Types (Grain(..))\n\ncorpus :: Corpus\ncorpus = (testContext, testOptions, allExamples)\n\nnegativeCorpus :: NegativeCorpus\nnegativeCorpus = (testContext, testOptions, examples)\n where\n examples =\n [ \"for months\"\n , \"in days\"\n , \"secretary\"\n , \"minutes\"\n , \"I second that\"\n ]\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (DurationData 1 Second)\n [ \"one sec\"\n , \"1 second\"\n , \"1\\\"\"\n ]\n , examples (DurationData 2 Minute)\n [ \"2 mins\"\n , \"two minutes\"\n , \"2'\"\n , \"2 more minutes\"\n , \"two additional minutes\"\n , \"2 extra minutes\"\n , \"2 less minutes\"\n , \"2 fewer minutes\"\n , \"2m\"\n , \"2 m\"\n ]\n , examples (DurationData 30 Day)\n [ \"30 days\"\n ]\n , examples (DurationData 7 Week)\n [ \"seven weeks\"\n ]\n , examples (DurationData 1 Month)\n [ \"1 month\"\n , \"a month\"\n ]\n , examples (DurationData 3 Quarter)\n [ \"3 quarters\"\n ]\n , examples (DurationData 2 Year)\n [ \"2 years\"\n ]\n , examples (DurationData 30 Minute)\n [ \"half an hour\"\n , \"half hour\"\n , \"1/2 hour\"\n , \"1/2h\"\n , \"1/2 h\"\n ]\n , examples (DurationData 12 Hour)\n [ \"half a day\"\n , \"half day\"\n , \"1/2 day\"\n ]\n , examples (DurationData 90 Minute)\n [ \"an hour and a half\"\n , \"one hour and half\"\n , \"1 hour thirty\"\n , \"1 hour and thirty\"\n , \"1.5 hours\"\n , \"1.5 hrs\"\n , \"one and two quarter hour\"\n , \"one and two quarters hour\"\n , \"one and two quarter of hour\"\n , \"one and two quarters of hour\"\n ]\n , examples (DurationData 75 Minute)\n [ \"1 hour fifteen\"\n , \"1 hour and fifteen\"\n , \"one and quarter hour\"\n , \"one and a quarter hour\"\n , \"one and one quarter hour\"\n , \"one and quarter of hour\"\n , \"one and a quarter of hour\"\n , \"one and one quarter of hour\"\n ]\n , examples (DurationData 130 Minute)\n [ \"2 hours ten\"\n , \"2 hour and 10\"\n ]\n , examples (DurationData 3615 Second)\n [ \"1 hour fifteen seconds\"\n , \"1 hour and fifteen seconds\"\n ]\n , examples (DurationData 45 Day)\n [ \"a month and a half\"\n , \"one month and half\"\n ]\n , examples (DurationData 27 Month)\n [ \"2 years and 3 months\"\n , \"2 years, 3 months\"\n , \"2 years 3 months\"\n ]\n , examples (DurationData 31719604 Second)\n [ \"1 year, 2 days, 3 hours and 4 seconds\"\n , \"1 year 2 days 3 hours and 4 seconds\"\n -- Oxford comma not supported:\n-- , \"1 year, 2 days, 3 hours, and 4 seconds\"\n ]\n , examples (DurationData 330 Second)\n [ \"5 and a half minutes\"\n , \"five and half min\"\n , \"5 and an half minute\"\n ]\n , examples (DurationData 105 Minute)\n [ \"one and three quarter hour\"\n , \"one and three quarters hour\"\n , \"one and three quarter of hour\"\n , \"one and three quarters of hour\"\n , \"one and three quarter of hours\"\n , \"one and three quarters of hours\"\n ]\n , examples (DurationData 135 Minute)\n [ \"two and quarter hour\"\n , \"two and a quarter of hour\"\n , \"two and quarter of hours\"\n , \"two and a quarter of hours\"\n ]\n , examples (DurationData 105 Minute)\n [ \"an hour and 45 minutes\"\n , \"one hour and 45 minutes\"\n ]\n , examples (DurationData 90 Second)\n [ \"a minute and 30 seconds\"\n , \"one minute and 30 seconds\"\n ]\n , examples (DurationData 3630 Second)\n [ \"an hour and 30 seconds\"]\n , examples (DurationData 930 Second)\n [ \"15.5 minutes\"\n , \"15.5 minute\"\n , \"15.5 mins\"\n , \"15.5 min\"\n ]\n ]\n", "num_lines": 164} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE NoRebindableSyntax #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Duration.EN.Rules\n ( rules\n ) where\n\nimport Prelude\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Duration.Helpers\nimport Duckling.Duration.Types (DurationData(..))\nimport Duckling.Numeral.Helpers (numberBetween, parseInteger)\nimport Duckling.Numeral.Types (NumeralData(..))\nimport Duckling.Regex.Types\nimport Duckling.Types\nimport qualified Duckling.Duration.Types as TDuration\nimport qualified Duckling.Numeral.Types as TNumeral\nimport qualified Duckling.TimeGrain.Types as TG\n\nruleDurationQuarterOfAnHour :: Rule\nruleDurationQuarterOfAnHour = Rule\n { name = \"quarter of an hour\"\n , pattern =\n [ regex \"(1/4\\\\s?h(our)?|(a\\\\s)?quarter of an hour)\"\n ]\n , prod = \\_ -> Just $ Token Duration $ duration TG.Minute 15\n }\n\nruleDurationHalfAnHourAbbrev :: Rule\nruleDurationHalfAnHourAbbrev = Rule\n { name = \"half an hour (abbrev).\"\n , pattern =\n [ regex \"1/2\\\\s?h\"\n ]\n , prod = \\_ -> Just $ Token Duration $ duration TG.Minute 30\n }\n\nruleDurationThreeQuartersOfAnHour :: Rule\nruleDurationThreeQuartersOfAnHour = Rule\n { name = \"three-quarters of an hour\"\n , pattern =\n [ regex \"(3/4\\\\s?h(our)?|three(\\\\s|-)quarters of an hour)\"\n ]\n , prod = \\_ -> Just $ Token Duration $ duration TG.Minute 45\n }\n\nruleDurationFortnight :: Rule\nruleDurationFortnight = Rule\n { name = \"fortnight\"\n , pattern =\n [ regex \"(a|one)? fortnight\"\n ]\n , prod = \\_ -> Just $ Token Duration $ duration TG.Day 14\n }\n\nruleNumeralQuotes :: Rule\nruleNumeralQuotes = Rule\n { name = \" + '\\\"\"\n , pattern =\n [ Predicate isNatural\n , regex \"(['\\\"])\"\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = v}:\n Token RegexMatch (GroupMatch (x:_)):\n _) -> case x of\n \"'\" -> Just $ Token Duration $ duration TG.Minute $ floor v\n \"\\\"\" -> Just $ Token Duration $ duration TG.Second $ floor v\n _ -> Nothing\n _ -> Nothing\n }\n\nruleDurationNumeralMore :: Rule\nruleDurationNumeralMore = Rule\n { name = \" more \"\n , pattern =\n [ Predicate isNatural\n , regex \"more|additional|extra|less|fewer\"\n , dimension TimeGrain\n ]\n , prod = \\case\n (Token Numeral nd:_:Token TimeGrain grain:_) ->\n Just $ Token Duration $ duration grain $ floor $ TNumeral.value nd\n _ -> Nothing\n }\n\nruleDurationDotNumeralHours :: Rule\nruleDurationDotNumeralHours = Rule\n { name = \"number.number hours\"\n , pattern =\n [ regex \"(\\\\d+)\\\\.(\\\\d+)\"\n , Predicate $ isGrain TG.Hour\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (h:m:_)):_) -> do\n hh <- parseInteger h\n mnum <- parseInteger m\n let mden = 10 ^ Text.length m\n Just $ Token Duration $ minutesFromHourMixedFraction hh mnum mden\n _ -> Nothing\n }\n\nruleDurationAndHalfHour :: Rule\nruleDurationAndHalfHour = Rule\n { name = \" and an half hour\"\n , pattern =\n [ Predicate isNatural\n , regex \"and (an? )?half hours?\"\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = v}:_) ->\n Just $ Token Duration $ duration TG.Minute $ 30 + 60 * floor v\n _ -> Nothing\n }\n\nruleDurationAndHalfMinute :: Rule\nruleDurationAndHalfMinute = Rule\n { name = \" and a half minutes\"\n , pattern =\n [ Predicate isNatural\n , regex \"and (an? )?half min(ute)?s?\"\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = v}:_) ->\n Just $ Token Duration $ duration TG.Second $ 30 + 60 * floor v\n _ -> Nothing\n }\n\nruleDurationA :: Rule\nruleDurationA = Rule\n { name = \"a \"\n , pattern =\n [ regex \"an?\"\n , dimension TimeGrain\n ]\n , prod = \\case\n (_:Token TimeGrain grain:_) -> Just $ Token Duration $ duration grain 1\n _ -> Nothing\n }\n\nruleDurationHalfATimeGrain :: Rule\nruleDurationHalfATimeGrain = Rule\n { name = \"half a \"\n , pattern =\n [ regex \"(1/2|half)( an?)?\"\n , dimension TimeGrain\n ]\n , prod = \\case\n (_:Token TimeGrain grain:_) -> Token Duration <$> nPlusOneHalf grain 0\n _ -> Nothing\n }\n\nruleDurationOneGrainAndHalf :: Rule\nruleDurationOneGrainAndHalf = Rule\n { name = \"a and a half\"\n , pattern =\n [ regex \"an?|one\"\n , dimension TimeGrain\n , regex \"and (a )?half\"\n ]\n , prod = \\case\n (_:Token TimeGrain grain:_) -> Token Duration <$> nPlusOneHalf grain 1\n _ -> Nothing\n }\n\nruleDurationHoursAndMinutes :: Rule\nruleDurationHoursAndMinutes = Rule\n { name = \" hour and \"\n , pattern =\n [ Predicate isNatural\n , regex \"hours?( and)?\"\n , Predicate $ and . sequence [isNatural, numberBetween 1 60]\n ]\n , prod = \\case\n (Token Numeral h:\n _:\n Token Numeral m:\n _) -> Just $ Token Duration $ duration TG.Minute $\n floor (TNumeral.value m) + 60 * floor (TNumeral.value h)\n _ -> Nothing\n }\n\nruleDurationPrecision :: Rule\nruleDurationPrecision = Rule\n { name = \"about|exactly \"\n , pattern =\n [ regex \"(about|around|approximately|exactly)\"\n , dimension Duration\n ]\n , prod = \\case\n (_:token:_) -> Just token\n _ -> Nothing\n }\n\n-- | NOTE: Oxford comma is not supported.\nruleCompositeDurationCommasAnd :: Rule\nruleCompositeDurationCommasAnd = Rule\n { name = \"composite (with ,/and)\"\n , pattern =\n [ Predicate isNatural\n , dimension TimeGrain\n , regex \",|and\"\n , dimension Duration\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = v}:\n Token TimeGrain g:\n _:\n Token Duration dd@DurationData{TDuration.grain = dg}:\n _) | g > dg -> Just $ Token Duration $ duration g (floor v) <> dd\n _ -> Nothing\n }\n\nruleCompositeDuration :: Rule\nruleCompositeDuration = Rule\n { name = \"composite \"\n , pattern =\n [ Predicate isNatural\n , dimension TimeGrain\n , dimension Duration\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = v}:\n Token TimeGrain g:\n Token Duration dd@DurationData{TDuration.grain = dg}:\n _) | g > dg -> Just $ Token Duration $ duration g (floor v) <> dd\n _ -> Nothing\n }\n\nruleCompositeDurationAnd :: Rule\nruleCompositeDurationAnd = Rule\n { name = \"composite and \"\n , pattern =\n [ dimension Duration\n , regex \",|and\"\n , dimension Duration\n ]\n , prod = \\case\n (Token Duration DurationData{TDuration.value = v, TDuration.grain = g}:\n _:\n Token Duration dd@DurationData{TDuration.grain = dg}:\n _) | g > dg -> Just $ Token Duration $ duration g v <> dd\n _ -> Nothing\n }\n\nruleDurationDotNumeralMinutes :: Rule\nruleDurationDotNumeralMinutes = Rule\n { name = \"number.number minutes\"\n , pattern =\n [ regex \"(\\\\d+)\\\\.(\\\\d+)\"\n , Predicate $ isGrain TG.Minute\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (m:s:_)):_) -> do\n mm <- parseInteger m\n ss <- parseInteger s\n let sden = 10 ^ Text.length s\n Just $ Token Duration $ secondsFromHourMixedFraction mm ss sden\n _ -> Nothing\n }\n\nruleDurationNumeralAndQuarterHour :: Rule\nruleDurationNumeralAndQuarterHour = Rule\n { name = \" and quarter of hour\"\n , pattern =\n [ Predicate isNatural\n , regex \"and (a |an |one |two |three )?quarters?( of)?( an)?\"\n , Predicate $ isGrain TG.Hour\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = h}:\n Token RegexMatch (GroupMatch (match:_)):\n _) -> do\n q <- case Text.strip $ Text.toLower match of \"a\" -> Just 1\n \"an\" -> Just 1\n \"one\" -> Just 1\n \"two\" -> Just 2\n \"three\" -> Just 3\n _ -> Just 1\n Just $ Token Duration $ duration TG.Minute $ 15 * q + 60 * floor h\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleCompositeDurationCommasAnd\n , ruleDurationQuarterOfAnHour\n , ruleDurationHalfAnHourAbbrev\n , ruleDurationThreeQuartersOfAnHour\n , ruleDurationFortnight\n , ruleDurationNumeralMore\n , ruleDurationDotNumeralHours\n , ruleDurationAndHalfHour\n , ruleDurationAndHalfMinute\n , ruleDurationA\n , ruleDurationHalfATimeGrain\n , ruleDurationOneGrainAndHalf\n , ruleDurationHoursAndMinutes\n , ruleDurationPrecision\n , ruleNumeralQuotes\n , ruleCompositeDuration\n , ruleCompositeDurationAnd\n , ruleCompositeDurationCommasAnd\n , ruleDurationDotNumeralMinutes\n , ruleDurationNumeralAndQuarterHour\n ]\n", "num_lines": 318} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Duration.ES.Corpus\n ( corpus\n ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Duration.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Testing.Types\nimport Duckling.TimeGrain.Types (Grain(..))\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale ES Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (DurationData 30 Minute)\n [ \"media hora\"\n , \"media horas\"\n , \"30 minutos\"\n , \"treinta minutos\"\n ]\n , examples (DurationData 15 Minute)\n [ \"cuarto de hora\"\n , \"cuartos de hora\"\n , \"quince minutos\"\n , \"15 minutos\"\n ]\n , examples (DurationData 45 Minute)\n [ \"tres cuartos de hora\"\n , \"tres cuartos de horas\"\n , \"tres cuarto de hora\"\n , \"tres cuarto de horas\"\n , \"cuarenta y cinco minutos\"\n , \"45 minutos\"\n ]\n , examples (DurationData 92 Minute)\n [\n \"una hora y treinta y dos minutos\"\n , \"una hora treinta y dos minutos\"\n ]\n , examples (DurationData 155 Minute)\n [\n \"dos hora y treinta y cinco minutos\"\n , \"dos hora treinta y cinco minutos\"\n ]\n ]\n", "num_lines": 59} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE NoRebindableSyntax #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Duration.ES.Rules\n ( rules\n ) where\n\nimport Prelude\nimport Data.Semigroup ((<>))\nimport Duckling.Dimensions.Types\nimport Duckling.Duration.Helpers\nimport Duckling.Duration.Types (DurationData(..))\nimport Duckling.Numeral.Types (NumeralData(..))\nimport Duckling.Types\nimport qualified Duckling.Duration.Types as TDuration\nimport qualified Duckling.Numeral.Types as TNumeral\nimport qualified Duckling.TimeGrain.Types as TG\n\nruleDurationQuarterOfAnHour :: Rule\nruleDurationQuarterOfAnHour = Rule\n { name = \"quarter of an hour\"\n , pattern =\n [ regex \"cuartos? de hora\"\n ]\n , prod = \\_ -> Just $ Token Duration $ duration TG.Minute 15\n }\n\nruleDurationHalfOfAnHour :: Rule\nruleDurationHalfOfAnHour = Rule\n { name = \"half of an hour\"\n , pattern =\n [ regex \"media horas?\"\n ]\n , prod = \\_ -> Just $ Token Duration $ duration TG.Minute 30\n }\n\nruleDurationThreeQuartersOfAnHour :: Rule\nruleDurationThreeQuartersOfAnHour = Rule\n { name = \"three-quarters of an hour\"\n , pattern =\n [ regex \"tres cuartos? de horas?\"\n ]\n , prod = \\_ -> Just $ Token Duration $ duration TG.Minute 45\n }\n\nruleCompositeDurationCommasAnd :: Rule\nruleCompositeDurationCommasAnd = Rule\n { name = \"composite (with and)\"\n , pattern =\n [ Predicate isNatural\n , dimension TimeGrain\n , regex \"y\"\n , dimension Duration\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = v}:\n Token TimeGrain g:\n _:\n Token Duration dd@DurationData{TDuration.grain = dg}:\n _) | g > dg -> Just $ Token Duration $ duration g (floor v) <> dd\n _ -> Nothing\n }\n\nruleCompositeDuration :: Rule\nruleCompositeDuration = Rule\n {\n name = \"composite \"\n , pattern =\n [\n Predicate isNatural\n , dimension TimeGrain\n , dimension Duration\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = v}:\n Token TimeGrain g:\n Token Duration dd@DurationData{TDuration.grain = dg}:\n _) | g > dg -> Just $ Token Duration $ duration g (floor v) <> dd\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleDurationHalfOfAnHour\n , ruleDurationQuarterOfAnHour\n , ruleDurationThreeQuartersOfAnHour\n , ruleCompositeDuration\n , ruleCompositeDurationCommasAnd\n ]\n", "num_lines": 99} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Duration.FR.Corpus\n ( corpus\n , negativeCorpus\n ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Duration.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Testing.Types\nimport Duckling.TimeGrain.Types (Grain(..))\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale FR Nothing}, testOptions, allExamples)\n\nnegativeCorpus :: NegativeCorpus\nnegativeCorpus = (testContext {locale = makeLocale FR Nothing}, testOptions, examples)\n where\n examples =\n [ \"les jours\"\n , \"en secondaire\"\n , \"minutes\"\n , \"pendant des mois\"\n ]\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (DurationData 1 Second)\n [ \"une sec\"\n , \"1 seconde\"\n , \"1\\\"\"\n ]\n , examples (DurationData 2 Minute)\n [ \"2 mins\"\n , \"deux minutes\"\n , \"2'\"\n ]\n , examples (DurationData 30 Day)\n [ \"30 jours\"\n ]\n , examples (DurationData 7 Week)\n [ \"sept semaines\"\n ]\n , examples (DurationData 1 Month)\n [ \"1 mois\"\n , \"un mois\"\n ]\n , examples (DurationData 3 Quarter)\n [ \"3 trimestres\"\n ]\n , examples (DurationData 2 Year)\n [ \"2 ans\"\n ]\n ]\n", "num_lines": 66} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Duration.FR.Rules\n ( rules ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Dimensions.Types\nimport Duckling.Duration.Helpers\nimport Duckling.Numeral.Types (NumeralData(..))\nimport qualified Duckling.Numeral.Types as TNumeral\nimport Duckling.Regex.Types\nimport qualified Duckling.TimeGrain.Types as TG\nimport Duckling.Types\n\nruleNumeralQuotes :: Rule\nruleNumeralQuotes = Rule\n { name = \" + '\\\"\"\n , pattern =\n [ Predicate isNatural\n , regex \"(['\\\"])\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v}:\n Token RegexMatch (GroupMatch (x:_)):\n _) -> case x of\n \"'\" -> Just . Token Duration . duration TG.Minute $ floor v\n \"\\\"\" -> Just . Token Duration . duration TG.Second $ floor v\n _ -> Nothing\n _ -> Nothing\n }\n\nruleUneUnitofduration :: Rule\nruleUneUnitofduration = Rule\n { name = \"une \"\n , pattern =\n [ regex \"une|la|le?\"\n , dimension TimeGrain\n ]\n , prod = \\tokens -> case tokens of\n (_:\n Token TimeGrain grain:\n _) -> Just . Token Duration $ duration grain 1\n _ -> Nothing\n }\n\nruleUnQuartDHeure :: Rule\nruleUnQuartDHeure = Rule\n { name = \"un quart d'heure\"\n , pattern =\n [ regex \"(1/4\\\\s?h(eure)?|(un|1) quart d'heure)\"\n ]\n , prod = \\_ -> Just . Token Duration $ duration TG.Minute 15\n }\n\nruleUneDemiHeure :: Rule\nruleUneDemiHeure = Rule\n { name = \"une demi heure\"\n , pattern =\n [ regex \"(1/2\\\\s?h(eure)?|(1|une) demi(e)?(\\\\s|-)heure)\"\n ]\n , prod = \\_ -> Just . Token Duration $ duration TG.Minute 30\n }\n\nruleTroisQuartsDHeure :: Rule\nruleTroisQuartsDHeure = Rule\n { name = \"trois quarts d'heure\"\n , pattern =\n [ regex \"(3/4\\\\s?h(eure)?|(3|trois) quart(s)? d'heure)\"\n ]\n , prod = \\_ -> Just . Token Duration $ duration TG.Minute 45\n }\n\nruleDurationEnviron :: Rule\nruleDurationEnviron = Rule\n { name = \"environ \"\n , pattern =\n [ regex \"environ\"\n ]\n , prod = \\tokens -> case tokens of\n -- TODO(jodent) +precision approximate\n (_:token:_) -> Just token\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleUneUnitofduration\n , ruleUnQuartDHeure\n , ruleUneDemiHeure\n , ruleTroisQuartsDHeure\n , ruleDurationEnviron\n , ruleNumeralQuotes\n ]\n", "num_lines": 104} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Duration.GA.Corpus\n ( corpus\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Duration.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Testing.Types\nimport Duckling.TimeGrain.Types (Grain(..))\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale GA Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (DurationData 1 Second)\n [ \"aon soicind amhain\"\n , \"aon soicind\"\n , \"1 tshoicindi\"\n , \"1 tsoicind\"\n ]\n , examples (DurationData 30 Minute)\n [ \"leathuair\"\n , \"30 noimead\"\n ]\n , examples (DurationData 27 Minute)\n [ \"7 noimead 20\"\n ]\n , examples (DurationData 14 Day)\n [ \"coic\u00c3\u00ads\"\n ]\n ]\n", "num_lines": 45} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Duration.GA.Rules\n ( rules ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Dimensions.Types\nimport Duckling.Duration.Helpers\nimport Duckling.Numeral.Helpers (numberWith)\nimport Duckling.Numeral.Types (NumeralData(..))\nimport qualified Duckling.Numeral.Types as TNumeral\nimport qualified Duckling.TimeGrain.Types as TG\nimport Duckling.Types\n\nruleCoics :: Rule\nruleCoics = Rule\n { name = \"coic\u00c3\u00ads\"\n , pattern =\n [ regex \"coic(\u00c3\u00ad|i)s(\u00c3\u00ad|i|e)?\"\n ]\n , prod = \\_ -> Just . Token Duration $ duration TG.Day 14\n }\n\nruleLeathuair :: Rule\nruleLeathuair = Rule\n { name = \"leathuair\"\n , pattern =\n [ regex \"leathuair(e|eanta)?\"\n ]\n , prod = \\_ -> Just . Token Duration $ duration TG.Minute 30\n }\n\nruleAonDurationAmhain :: Rule\nruleAonDurationAmhain = Rule\n { name = \"aon X amhain\"\n , pattern =\n [ numberWith TNumeral.value (== 1)\n , dimension TimeGrain\n , numberWith TNumeral.value (== 1)\n ]\n , prod = \\tokens -> case tokens of\n (_:Token TimeGrain grain:_) -> Just . Token Duration $ duration grain 1\n _ -> Nothing\n }\n\nruleIntegerUnitofdurationInteger :: Rule\nruleIntegerUnitofdurationInteger = Rule\n { name = \" \"\n , pattern =\n [ numberWith TNumeral.value (< 10)\n , dimension TimeGrain\n , numberWith TNumeral.value (`elem` [10, 20 .. 50])\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v1}:\n Token TimeGrain grain:\n Token Numeral NumeralData{TNumeral.value = v2}:\n _) -> Just . Token Duration . duration grain . floor $ v1 + v2\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleCoics\n , ruleIntegerUnitofdurationInteger\n , ruleLeathuair\n , ruleAonDurationAmhain\n ]\n", "num_lines": 79} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Duration.HE.Rules\n ( rules ) where\n\nimport Control.Monad (join)\nimport Data.Maybe\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Duration.Helpers\nimport Duckling.Duration.Types (DurationData (..))\nimport Duckling.Numeral.Helpers (parseInteger)\nimport Duckling.Numeral.Types (NumeralData(..))\nimport Duckling.Regex.Types\nimport Duckling.Types\nimport qualified Duckling.Duration.Types as TDuration\nimport qualified Duckling.Numeral.Types as TNumeral\nimport qualified Duckling.TimeGrain.Types as TG\n\nruleQuarterOfAnHour :: Rule\nruleQuarterOfAnHour = Rule\n { name = \"quarter of an hour\"\n , pattern =\n [ regex \"(1/4/s \u00d7\u00a9\u00d7\u00a2\u00d7\u201d|\u00d7\u00a8\u00d7\u2018\u00d7\u00a2 \u00d7\u00a9\u00d7\u00a2\u00d7\u201d)\"\n ]\n , prod = \\_ -> Just . Token Duration $ duration TG.Minute 15\n }\n\nruleHalfAnHour :: Rule\nruleHalfAnHour = Rule\n { name = \"half an hour\"\n , pattern =\n [ regex \"(1/2/s \u00d7\u00a9\u00d7\u00a2\u00d7\u201d|\u00d7\u2014\u00d7\u00a6\u00d7\u2122 \u00d7\u00a9\u00d7\u00a2\u00d7\u201d)\"\n ]\n , prod = \\_ -> Just . Token Duration $ duration TG.Minute 30\n }\n\nruleThreequartersOfAnHour :: Rule\nruleThreequartersOfAnHour = Rule\n { name = \"three-quarters of an hour\"\n , pattern =\n [ regex \"(3/4/s \u00d7\u00a9\u00d7\u00a2\u00d7\u201d|\u00d7\u00a9\u00d7\u0153\u00d7\u2022\u00d7\u00a9\u00d7\u00aa \u00d7\u00a8\u00d7\u2018\u00d7\u00a2\u00d7\u2122 \u00d7\u00a9\u00d7\u00a2\u00d7\u201d)\"\n ]\n , prod = \\_ -> Just . Token Duration $ duration TG.Minute 45\n }\n\nruleNumbernumberHours :: Rule\nruleNumbernumberHours = Rule\n { name = \"number.number hours\"\n , pattern =\n [ regex \"(\\\\d+)\\\\.(\\\\d+)\"\n , regex \"\u00d7\u00a9\u00d7\u00a2\u00d7\u201d|\u00d7\u00a9\u00d7\u00a2\u00d7\u2022\u00d7\u00aa\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (h:m:_)):_) -> do\n hh <- parseInteger h\n mnum <- parseInteger m\n let mden = 10 ^ Text.length m\n Just . Token Duration $ minutesFromHourMixedFraction hh mnum mden\n _ -> Nothing\n }\n\nruleIntegerAndAnHalfHours :: Rule\nruleIntegerAndAnHalfHours = Rule\n { name = \" and an half hours\"\n , pattern =\n [ Predicate isNatural\n , regex \"\u00d7\u2022\u00d7\u2014\u00d7\u00a6\u00d7\u2122 (\u00d7\u00a9\u00d7\u00a2\u00d7\u2022\u00d7\u00aa|\u00d7\u00a9\u00d7\u00a2\u00d7\u201d)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v}:_) ->\n Just . Token Duration . duration TG.Minute $ 30 + 60 * floor v\n _ -> Nothing\n }\n\nruleAboutDuration :: Rule\nruleAboutDuration = Rule\n { name = \"about \"\n , pattern =\n [ regex \"(\u00d7\u2018\u00d7\u00a2\u00d7\u00a8\u00d7\u0161|\u00d7\u00a1\u00d7\u2018\u00d7\u2122\u00d7\u2018\u00d7\u2022\u00d7\u00aa|\u00d7\u2018\u00d7\u00a7\u00d7\u2122\u00d7\u00a8\u00d7\u2022\u00d7\u2018)\"\n , dimension Duration\n ]\n , prod = \\tokens -> case tokens of\n (_:token:_) -> Just token\n _ -> Nothing\n }\n\nruleExactlyDuration :: Rule\nruleExactlyDuration = Rule\n { name = \"exactly \"\n , pattern =\n [ regex \"\u00d7\u2018\u00d7\u201c\u00d7\u2122\u00d7\u2022\u00d7\u00a7\"\n , dimension Duration\n ]\n , prod = \\tokens -> case tokens of\n (_:token:_) -> Just token\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleAboutDuration\n , ruleExactlyDuration\n , ruleHalfAnHour\n , ruleIntegerAndAnHalfHours\n , ruleNumbernumberHours\n , ruleQuarterOfAnHour\n , ruleThreequartersOfAnHour\n ]\n", "num_lines": 121} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Duration.HU.Corpus\n ( corpus ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Duration.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Testing.Types\nimport Duckling.TimeGrain.Types (Grain(..))\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale HU Nothing}, testOptions, allExamples)\n\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (DurationData 1 Second)\n [ \"egy m\u00c3\u00a1sodperc\"\n , \"1 m\u00c3\u00a1sodperc\"\n ]\n , examples (DurationData 2 Minute)\n [ \"2 perc\"\n , \"kett\u00c5\u2018 perc\"\n ]\n , examples (DurationData 15 Minute)\n [ \"negyed \u00c3\u00b3ra\"\n , \"negyed\u00c3\u00b3ra\"\n , \"negyed-\u00c3\u00b3ra\"\n ]\n , examples (DurationData 30 Minute)\n [ \"f\u00c3\u00a9l \u00c3\u00b3ra\"\n , \"f\u00c3\u00a9l\u00c3\u00b3ra\"\n , \"f\u00c3\u00a9l-\u00c3\u00b3ra\"\n ]\n , examples (DurationData 45 Minute)\n [ \"h\u00c3\u00a1romnegyed \u00c3\u00b3ra\"\n , \"h\u00c3\u00a1romnegyed-\u00c3\u00b3ra\"\n , \"h\u00c3\u00a1romnegyed\u00c3\u00b3ra\"\n , \"3/4 \u00c3\u00b3ra\"\n , \"3/4\u00c3\u00b3ra\"\n ]\n , examples (DurationData 150 Minute)\n [ \"2.5 \u00c3\u00b3ra\"\n , \"kett\u00c5\u2018 \u00c3\u00a9s f\u00c3\u00a9l \u00c3\u00b3ra\"\n , \"kett\u00c5\u2018 \u00c3\u00a9s f\u00c3\u00a9l-\u00c3\u00b3ra\"\n , \"kett\u00c5\u2018 \u00c3\u00a9s f\u00c3\u00a9l\u00c3\u00b3ra\"\n ]\n , examples (DurationData 30 Day)\n [ \"30 nap\"\n ]\n , examples (DurationData 7 Week)\n [ \"h\u00c3\u00a9t h\u00c3\u00a9t\"\n ]\n , examples (DurationData 1 Month)\n [ \"egy h\u00c3\u00b3nap\"\n ]\n , examples (DurationData 3 Quarter)\n [ \"3 negyed\u00c3\u00a9v\"\n ]\n , examples (DurationData 2 Year)\n [ \"2 \u00c3\u00a9v\"\n ]\n ]\n", "num_lines": 74} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Duration.HU.Rules\n ( rules ) where\n\nimport Control.Monad (join)\nimport Data.String\nimport Prelude\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Duration.Helpers\nimport Duckling.Numeral.Helpers (parseInt, parseInteger)\nimport Duckling.Numeral.Types (NumeralData(..))\nimport Duckling.Regex.Types\nimport Duckling.Types\nimport qualified Duckling.Numeral.Types as TNumeral\nimport qualified Duckling.TimeGrain.Types as TG\n\nruleDurationQuarterOfAnHour :: Rule\nruleDurationQuarterOfAnHour = Rule\n { name = \"quarter of an hour\"\n , pattern =\n [ regex \"(negyed[\\\\s-]?\\x00F3ra)\"\n ]\n , prod = \\_ -> Just . Token Duration $ duration TG.Minute 15\n }\n\nruleDurationHalfAnHour :: Rule\nruleDurationHalfAnHour = Rule\n { name = \"half an hour\"\n , pattern =\n [ regex \"(f\\x00E9l[\\\\s-]?\\x00F3ra)\"\n ]\n , prod = \\_ -> Just . Token Duration $ duration TG.Minute 30\n }\n\nruleDurationThreeQuartersOfAnHour :: Rule\nruleDurationThreeQuartersOfAnHour = Rule\n { name = \"three-quarters of an hour\"\n , pattern =\n [ regex \"(3/4[\\\\s-]?\u00c3\u00b3ra|h\\x00E1romnegyed[\\\\s-]?\\x00F3ra)\"\n ]\n , prod = \\_ -> Just . Token Duration $ duration TG.Minute 45\n }\n\nruleDurationDotNumeralHours :: Rule\nruleDurationDotNumeralHours = Rule\n { name = \"number.number hours\"\n , pattern =\n [ regex \"(\\\\d+)\\\\.(\\\\d+) \u00c3\u00b3ra\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (h:m:_)):_) -> do\n hh <- parseInteger h\n mnum <- parseInteger m\n let mden = 10 ^ Text.length m\n Just . Token Duration $ minutesFromHourMixedFraction hh mnum mden\n _ -> Nothing\n }\n\nruleDurationAndHalfHour :: Rule\nruleDurationAndHalfHour = Rule\n { name = \" and an half hour\"\n , pattern =\n [ Predicate isNatural\n , regex \"\\x00E9s f\\x00E9l[\\\\s-]?\\x00F3ra\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v}:_) ->\n Just . Token Duration . duration TG.Minute $ 30 + 60 * floor v\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleDurationQuarterOfAnHour\n , ruleDurationHalfAnHour\n , ruleDurationThreeQuartersOfAnHour\n , ruleDurationDotNumeralHours\n , ruleDurationAndHalfHour\n ]\n", "num_lines": 91} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Duration.IT.Rules\n ( rules ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Dimensions.Types\nimport Duckling.Duration.Helpers\nimport qualified Duckling.TimeGrain.Types as TG\nimport Duckling.Types\n\nruleUneUnitofduration :: Rule\nruleUneUnitofduration = Rule\n { name = \"une \"\n , pattern =\n [ regex \"un[a']?\"\n , dimension TimeGrain\n ]\n , prod = \\tokens -> case tokens of\n (_:Token TimeGrain grain:_) -> Just . Token Duration $ duration grain 1\n _ -> Nothing\n }\n\nruleUnQuartoDora :: Rule\nruleUnQuartoDora = Rule\n { name = \"un quarto d'ora\"\n , pattern =\n [ regex \"un quarto d['i] ?ora\"\n ]\n , prod = \\_ -> Just . Token Duration $ duration TG.Minute 15\n }\n\nruleMezzOra :: Rule\nruleMezzOra = Rule\n { name = \"mezz'ora\"\n , pattern =\n [ regex \"mezz[a'] ?ora\"\n ]\n , prod = \\_ -> Just . Token Duration $ duration TG.Minute 30\n }\n\nruleTreQuartiDora :: Rule\nruleTreQuartiDora = Rule\n { name = \"tre quarti d'ora\"\n , pattern =\n [ regex \"(3|tre) quarti d['i] ?ora\"\n ]\n , prod = \\_ -> Just . Token Duration $ duration TG.Minute 45\n }\n\nrules :: [Rule]\nrules =\n [ ruleUneUnitofduration\n , ruleUnQuartoDora\n , ruleMezzOra\n , ruleTreQuartiDora\n ]\n", "num_lines": 68} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Duration.KO.Corpus\n ( corpus\n ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Duration.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Testing.Types\nimport Duckling.TimeGrain.Types (Grain(..))\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale KO Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (DurationData 1 Second)\n [ \"1 \u00ec\u00b4\u02c6\"\n ]\n , examples (DurationData 30 Minute)\n [ \"\u00ec\u2039\u0153\u00ea\u00b0\u201e\u00eb\u00b0\u02dc\"\n , \"\u00ec\u2039\u0153\u00eb\u00b0\u02dc\"\n , \"\u00ec\u201e\u0153\u00eb\u00a5\u00b8\u00eb\u00b6\u201e\"\n ]\n , examples (DurationData 66 Minute)\n [ \"1.1 \u00ec\u2039\u0153\u00ea\u00b0\u201e\"\n ]\n ]\n", "num_lines": 40} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Duration.KO.Rules\n ( rules ) where\n\nimport Control.Monad (join)\nimport qualified Data.Text as Text\nimport Prelude\nimport Data.String\n\nimport Duckling.Dimensions.Types\nimport Duckling.Duration.Helpers\nimport Duckling.Numeral.Helpers (parseInteger)\nimport Duckling.Numeral.Types (NumeralData (..))\nimport qualified Duckling.Numeral.Types as TNumeral\nimport Duckling.Regex.Types\nimport qualified Duckling.TimeGrain.Types as TG\nimport Duckling.Types\n\nruleHalfAnHour :: Rule\nruleHalfAnHour = Rule\n { name = \"half an hour\"\n , pattern =\n [ Predicate $ isGrain TG.Hour\n , regex \"\u00eb\u00b0\u02dc\"\n ]\n , prod = \\_ -> Just . Token Duration $ duration TG.Minute 30\n }\n\nruleADay :: Rule\nruleADay = Rule\n { name = \"a day - \u00ed\u2022\u02dc\u00eb\u00a3\u00a8\"\n , pattern =\n [ regex \"\u00ed\u2022\u02dc\u00eb\u00a3\u00a8\"\n ]\n , prod = \\_ -> Just . Token Duration $ duration TG.Day 1\n }\n\nruleNumeralnumberHours :: Rule\nruleNumeralnumberHours = Rule\n { name = \"number.number hours\"\n , pattern =\n [ regex \"(\\\\d+)\\\\.(\\\\d+)\"\n , regex \"\u00ec\u2039\u0153\u00ea\u00b0\u201e\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (h:m:_)):_) -> do\n hh <- parseInteger h\n mnum <- parseInteger m\n let mden = 10 ^ Text.length m\n Just . Token Duration $ minutesFromHourMixedFraction hh mnum mden\n _ -> Nothing\n }\n\nruleIntegerAndAnHalfHours :: Rule\nruleIntegerAndAnHalfHours = Rule\n { name = \" and an half hours\"\n , pattern =\n [ Predicate isNatural\n , regex \"\u00ec\u2039\u0153\u00ea\u00b0\u201e\u00eb\u00b0\u02dc\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v}:_) ->\n Just . Token Duration . duration TG.Minute $ 30 + 60 * floor v\n _ -> Nothing\n }\n\nruleAboutDuration :: Rule\nruleAboutDuration = Rule\n { name = \"about \"\n , pattern =\n [ regex \"\u00eb\u0152\u20ac\u00ec\u00b6\u00a9|\u00ec\u2022\u00bd\"\n , dimension Duration\n ]\n , prod = \\tokens -> case tokens of\n (_:token:_) -> Just token\n _ -> Nothing\n }\n\nruleExactlyDuration :: Rule\nruleExactlyDuration = Rule\n { name = \"exactly \"\n , pattern =\n [ regex \"\u00ec\u00a0\u2022\u00ed\u2122\u2022\u00ed\u017e\u02c6\"\n , dimension Duration\n ]\n , prod = \\tokens -> case tokens of\n (_:token:_) -> Just token\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleADay\n , ruleAboutDuration\n , ruleExactlyDuration\n , ruleHalfAnHour\n , ruleIntegerAndAnHalfHours\n , ruleNumeralnumberHours\n ]\n", "num_lines": 109} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Duration.NB.Corpus\n ( corpus\n ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Duration.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Testing.Types\nimport Duckling.TimeGrain.Types (Grain(..))\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale NB Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (DurationData 1 Second)\n [ \"1 sek\"\n , \"en sek\"\n , \"ett sekund\"\n , \"e sekunder\"\n ]\n , examples (DurationData 30 Minute)\n [ \"tredve min\"\n , \"30 minutt\"\n , \"30 minutter\"\n , \"1/2 time\"\n , \"en halv time\"\n ]\n , examples (DurationData 2 Day)\n [ \"et par dager\"\n , \"2 dag\"\n , \"to dag\"\n ]\n ]\n", "num_lines": 47} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Duration.NB.Rules\n ( rules ) where\n\nimport Control.Monad (join)\nimport qualified Data.Text as Text\nimport Prelude\nimport Data.String\n\nimport Duckling.Dimensions.Types\nimport Duckling.Duration.Helpers\nimport Duckling.Numeral.Helpers (parseInteger)\nimport Duckling.Numeral.Types (NumeralData (..))\nimport qualified Duckling.Numeral.Types as TNumeral\nimport Duckling.Regex.Types\nimport qualified Duckling.TimeGrain.Types as TG\nimport Duckling.Types\n\nruleHalfAnHour :: Rule\nruleHalfAnHour = Rule\n { name = \"half an hour\"\n , pattern =\n [ regex \"(1/2|en halv) time\"\n ]\n , prod = \\_ -> Just . Token Duration $ duration TG.Minute 30\n }\n\nruleIntegerMoreUnitofduration :: Rule\nruleIntegerMoreUnitofduration = Rule\n { name = \" more \"\n , pattern =\n [ Predicate isNatural\n , dimension TimeGrain\n , regex \"mere?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v}:\n Token TimeGrain grain:\n _) -> Just . Token Duration . duration grain $ floor v\n _ -> Nothing\n }\n\nruleNumeralnumberHours :: Rule\nruleNumeralnumberHours = Rule\n { name = \"number.number hours\"\n , pattern =\n [ regex \"(\\\\d+)\\\\,(\\\\d+) *timer?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (h:m:_)):_) -> do\n hh <- parseInteger h\n mnum <- parseInteger m\n let mden = 10 ^ Text.length m\n Just . Token Duration $ minutesFromHourMixedFraction hh mnum mden\n _ -> Nothing\n }\n\nruleIntegerAndAnHalfHours :: Rule\nruleIntegerAndAnHalfHours = Rule\n { name = \" and an half hours\"\n , pattern =\n [ Predicate isNatural\n , regex \"og (en )?halv time?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v}:_) ->\n Just . Token Duration . duration TG.Minute $ 30 + 60 * floor v\n _ -> Nothing\n }\n\nruleAUnitofduration :: Rule\nruleAUnitofduration = Rule\n { name = \"a \"\n , pattern =\n [ regex \"en|ett|et?\"\n , dimension TimeGrain\n ]\n , prod = \\tokens -> case tokens of\n (_:Token TimeGrain grain:_) -> Just . Token Duration $ duration grain 1\n _ -> Nothing\n }\n\nruleAboutDuration :: Rule\nruleAboutDuration = Rule\n { name = \"about \"\n , pattern =\n [ regex \"(omkring|cirka|ca.|ca)\"\n , dimension Duration\n ]\n , prod = \\tokens -> case tokens of\n (_:token:_) -> Just token\n _ -> Nothing\n }\n\nruleExactlyDuration :: Rule\nruleExactlyDuration = Rule\n { name = \"exactly \"\n , pattern =\n [ regex \"(precis|akkurat)\"\n , dimension Duration\n ]\n , prod = \\tokens -> case tokens of\n (_:token:_) -> Just token\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleAUnitofduration\n , ruleAboutDuration\n , ruleExactlyDuration\n , ruleHalfAnHour\n , ruleIntegerAndAnHalfHours\n , ruleIntegerMoreUnitofduration\n , ruleNumeralnumberHours\n ]\n", "num_lines": 126} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Duration.NL.Corpus\n ( corpus\n , negativeCorpus\n ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Duration.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Testing.Types\nimport Duckling.TimeGrain.Types (Grain(..))\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale NL Nothing}, testOptions, allExamples)\n\nnegativeCorpus :: NegativeCorpus\nnegativeCorpus = (testContext {locale = makeLocale NL Nothing}, testOptions, examples)\n where\n examples =\n [ \"voor maanden\"\n , \"in enkele dagen\"\n , \"secretaris\"\n , \"last minute\"\n , \"12 uurtje\"\n ]\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (DurationData 1 Second)\n [ \"een seconde\"\n , \"\u00c3\u00a9\u00c3\u00a9n seconde\"\n , \"1 secondes\"\n , \"1 s\"\n , \"1\\\"\"\n ]\n , examples (DurationData 14 Second)\n [ \"veertien seconden\"\n , \"14 s\"\n ]\n , examples (DurationData 2 Minute)\n [ \"2 min\"\n , \"twee minuten\"\n , \"2 m\"\n , \"2'\"\n ]\n , examples (DurationData 45 Minute)\n [ \"3 kwartier\"\n ]\n , examples (DurationData 90 Minute)\n [ \"anderhalf uur\"\n ]\n , examples (DurationData 75 Minute)\n [ \"een uur en een kwartier\"\n , \"een uur en 15 minuten\"\n , \"een uur, 15 minuten\"\n , \"een uur 15 minuten\"\n ]\n , examples (DurationData 165 Minute)\n [ \"twee uur en drie kwartier\"\n , \"twee uur, 3 kwartier\"\n , \"twee uur, 45 minuten\"\n , \"twee uur 45 minuten\"\n ]\n , examples (DurationData 1 Hour)\n [ \"een uur\"\n , \"\u00c3\u00a9\u00c3\u00a9n uur\"\n , \"1 u\"\n , \"1 h\"\n ]\n , examples (DurationData 30 Day)\n [ \"30 dagen\"\n , \"4 weken en 2 dagen\"\n ]\n , examples (DurationData 7 Day)\n [ \"7 dagen\"\n ]\n , examples (DurationData 7 Week)\n [ \"zeven weken\"\n , \"7 w\"\n ]\n , examples (DurationData 1 Month)\n [ \"1 mnd\"\n , \"een maand\"\n , \"\u00c3\u00a9\u00c3\u00a9n maand\"\n ]\n , examples (DurationData 3 Quarter)\n [ \"drie kwartalen\"\n ]\n , examples (DurationData 2 Year)\n [ \"2 jaar\"\n , \"2 jaren\"\n , \"twee jaren\"\n , \"2 j\"\n ]\n , examples (DurationData 150 Minute)\n [ \"twee en een half uur\"\n , \"2,5 uur\"\n ]\n ]\n", "num_lines": 111} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n{-# LANGUAGE LambdaCase #-}\n\nmodule Duckling.Duration.NL.Rules\n ( rules ) where\n\nimport Control.Monad (join)\nimport Prelude\nimport Data.String\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Duration.Helpers\nimport Duckling.Duration.Types (DurationData(..))\nimport Duckling.Numeral.Helpers (parseInt, parseInteger)\nimport Duckling.Numeral.Types (NumeralData(..))\nimport Duckling.Regex.Types\nimport Duckling.Types\nimport qualified Duckling.Duration.Types as TDuration\nimport qualified Duckling.Numeral.Types as TNumeral\nimport qualified Duckling.TimeGrain.Types as TG\n\nruleDurationQuarterOfAnHour :: Rule\nruleDurationQuarterOfAnHour = Rule\n { name = \"quarter of an hour\"\n , pattern = [ regex \"1/4\\\\s?(h|u(ur)?)|kwartier\"]\n , prod = \\_ -> Just . Token Duration $ duration TG.Minute 15\n }\n\nruleDurationKwartier :: Rule\nruleDurationKwartier = Rule\n { name = \" kwartier\"\n , pattern =\n [ Predicate isNatural\n , regex \"kwartier\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v}:_) ->\n Just . Token Duration . duration TG.Minute $ 15 * floor v\n _ -> Nothing\n }\n\nruleDurationHalfAnHour :: Rule\nruleDurationHalfAnHour = Rule\n { name = \"half an hour\"\n , pattern = [regex \"(1/2\\\\s?uur|half uur)\"]\n , prod = \\_ -> Just . Token Duration $ duration TG.Minute 30\n }\n\nruleDurationThreeQuartersOfAnHour :: Rule\nruleDurationThreeQuartersOfAnHour = Rule\n { name = \"three-quarters of an hour\"\n , pattern = [regex \"3/4\\\\s?uur\"]\n , prod = \\_ -> Just . Token Duration $ duration TG.Minute 45\n }\n\nruleNumeralQuotes :: Rule\nruleNumeralQuotes = Rule\n { name = \" + '\\\"\"\n , pattern =\n [ Predicate isNatural\n , regex \"(['\\\"])\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v}:\n Token RegexMatch (GroupMatch (x:_)):\n _) -> case x of\n \"'\" -> Just . Token Duration . duration TG.Minute $ floor v\n \"\\\"\" -> Just . Token Duration . duration TG.Second $ floor v\n _ -> Nothing\n _ -> Nothing\n }\n\nruleDurationDotNumeralHours :: Rule\nruleDurationDotNumeralHours = Rule\n { name = \"number,number uur\"\n , pattern = [regex \"(\\\\d+)\\\\,(\\\\d+) *(uur|uren)\"]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (h:m:_)):_) -> do\n hh <- parseInteger h\n mnum <- parseInteger m\n let mden = 10 ^ Text.length m\n Just . Token Duration $ minutesFromHourMixedFraction hh mnum mden\n _ -> Nothing\n }\n\nruleDurationAndHalfHour :: Rule\nruleDurationAndHalfHour = Rule\n { name = \" and an half hour\"\n , pattern =\n [ Predicate isNatural\n , regex \"en een half (uur|uren)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v}:_) ->\n Just . Token Duration . duration TG.Minute $ 30 + 60 * floor v\n _ -> Nothing\n }\n\nruleDurationOneAndHalfHour :: Rule\nruleDurationOneAndHalfHour = Rule\n { name = \"1 and an half hour\"\n , pattern = [ regex \"anderhalf uur\"]\n , prod = \\_ -> Just . Token Duration $ duration TG.Minute 90\n }\n\n-- | NOTE: Oxford comma is not supported.\nruleCompositeDurationCommasAnd :: Rule\nruleCompositeDurationCommasAnd = Rule\n { name = \"composite (with ,/and)\"\n , pattern =\n [ Predicate isNatural\n , dimension TimeGrain\n , regex \",|en|plus\"\n , dimension Duration\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = v}:\n Token TimeGrain g:\n _:\n Token Duration dd@DurationData{TDuration.grain = dg}:\n _) | g > dg -> Just . Token Duration $ duration g (floor v) <> dd\n _ -> Nothing\n }\n\nruleCompositeDuration :: Rule\nruleCompositeDuration = Rule\n { name = \"composite \"\n , pattern =\n [ Predicate isNatural\n , dimension TimeGrain\n , dimension Duration\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = v}:\n Token TimeGrain g:\n Token Duration dd@DurationData{TDuration.grain = dg}:\n _) | g > dg -> Just . Token Duration $ duration g (floor v) <> dd\n _ -> Nothing\n }\n\nruleDurationPrecision :: Rule\nruleDurationPrecision = Rule\n { name = \"about|exactly \"\n , pattern =\n [ regex \"(ongeveer|precies|plusminus|exact)\"\n , dimension Duration\n ]\n , prod = \\tokens -> case tokens of\n (_:token:_) -> Just token\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleDurationQuarterOfAnHour\n , ruleDurationKwartier\n , ruleCompositeDurationCommasAnd\n , ruleCompositeDuration\n , ruleDurationHalfAnHour\n , ruleDurationThreeQuartersOfAnHour\n , ruleDurationDotNumeralHours\n , ruleDurationAndHalfHour\n , ruleDurationOneAndHalfHour\n , ruleDurationPrecision\n , ruleNumeralQuotes\n ]\n", "num_lines": 176} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Duration.PL.Corpus\n ( corpus\n ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Duration.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Testing.Types\nimport Duckling.TimeGrain.Types (Grain(..))\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale PL Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (DurationData 1 Second)\n [ \"1s\"\n , \"1 sekund\"\n , \"jeden sekundzie\"\n , \"pojedynczy sekundach\"\n , \"mniej wi\u00c4\u2122cej jedn\u00c4\u2026 sekund\u00c4\u2122\"\n ]\n , examples (DurationData 30 Minute)\n [ \"pol godziny\"\n , \"p\u00c3\u00b3\u00c5\u201a godziny\"\n , \"30m\"\n , \"30 minut\"\n , \"trzydzie\u00c5\u203aci minutami\"\n ]\n , examples (DurationData 5 Day)\n [ \"pi\u00c4\u2122ciu dniach\"\n ]\n , examples (DurationData 100 Day)\n [ \"sto dzie\u00c5\u201e\"\n , \"setki dni\u00c4\u2026\"\n ]\n ]\n", "num_lines": 50} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Duration.PL.Rules\n ( rules ) where\n\nimport Control.Monad (join)\nimport qualified Data.Text as Text\nimport Prelude\nimport Data.String\n\nimport Duckling.Dimensions.Types\nimport Duckling.Duration.Helpers\nimport Duckling.Numeral.Helpers (parseInteger)\nimport Duckling.Numeral.Types (NumeralData (..))\nimport qualified Duckling.Numeral.Types as TNumeral\nimport Duckling.Regex.Types\nimport qualified Duckling.TimeGrain.Types as TG\nimport Duckling.Types\n\nruleHalfAnHour :: Rule\nruleHalfAnHour = Rule\n { name = \"half an hour\"\n , pattern =\n [ regex \"p(o|\u00c3\u00b3)(l|\u00c5\u201a) godziny\"\n ]\n , prod = \\_ -> Just . Token Duration $ duration TG.Minute 30\n }\n\nruleIntegerMoreUnitofduration :: Rule\nruleIntegerMoreUnitofduration = Rule\n { name = \" more \"\n , pattern =\n [ Predicate isNatural\n , regex \"more|less\"\n , dimension TimeGrain\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v}:\n _:\n Token TimeGrain grain:\n _) -> Just . Token Duration . duration grain $ floor v\n _ -> Nothing\n }\n\nruleNumeralnumberHours :: Rule\nruleNumeralnumberHours = Rule\n { name = \"number.number hours\"\n , pattern =\n [ regex \"(\\\\d+)\\\\.(\\\\d+)\"\n , regex \"godzin(y)?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (h:m:_)):_) -> do\n hh <- parseInteger h\n mnum <- parseInteger m\n let mden = 10 ^ Text.length m\n Just . Token Duration $ minutesFromHourMixedFraction hh mnum mden\n _ -> Nothing\n }\n\nruleIntegerAndAnHalfHours :: Rule\nruleIntegerAndAnHalfHours = Rule\n { name = \" and an half hours\"\n , pattern =\n [ Predicate isNatural\n , regex \"i (p(o|\u00c3\u00b3)(l|\u00c5\u201a)) godziny\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v}:_) ->\n Just . Token Duration . duration TG.Minute $ 30 + 60 * floor v\n _ -> Nothing\n }\n\nruleUnitofdurationAsADuration :: Rule\nruleUnitofdurationAsADuration = Rule\n { name = \" as a duration\"\n , pattern =\n [ dimension TimeGrain\n ]\n , prod = \\tokens -> case tokens of\n (Token TimeGrain grain:_) ->\n Just . Token Duration $ duration grain 1\n _ -> Nothing\n }\n\nruleAboutDuration :: Rule\nruleAboutDuration = Rule\n { name = \"about \"\n , pattern =\n [ regex \"(oko(l|\u00c5\u201a)o|mniej wi(\u00c4\u2122|e)cej|jakie(s|\u00c5\u203a))\"\n , dimension Duration\n ]\n , prod = \\tokens -> case tokens of\n (_:token:_) -> Just token\n _ -> Nothing\n }\n\nruleExactlyDuration :: Rule\nruleExactlyDuration = Rule\n { name = \"exactly \"\n , pattern =\n [ regex \"r(o|\u00c3\u00b3)wno|dok(l|\u00c5\u201a)adnie\"\n , dimension Duration\n ]\n , prod = \\tokens -> case tokens of\n (_:token:_) -> Just token\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleAboutDuration\n , ruleExactlyDuration\n , ruleHalfAnHour\n , ruleIntegerAndAnHalfHours\n , ruleIntegerMoreUnitofduration\n , ruleNumeralnumberHours\n , ruleUnitofdurationAsADuration\n ]\n", "num_lines": 128} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Duration.PT.Corpus\n ( corpus\n ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Duration.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Testing.Types\nimport Duckling.TimeGrain.Types (Grain(..))\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale PT Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (DurationData 1 Second)\n [ \"um segundo\"\n , \"uma seg\"\n ]\n , examples (DurationData 2 Minute)\n [ \"duas mins\"\n , \"dois minutos\"\n ]\n , examples (DurationData 20 Day)\n [ \"20 dias\"\n , \"vinte d\u00c3\u00adas\"\n ]\n ]\n", "num_lines": 41} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Duration.RO.Corpus\n ( corpus\n ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Duration.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Testing.Types\nimport Duckling.TimeGrain.Types (Grain(..))\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale RO Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (DurationData 1 Second)\n [ \"o sec\"\n , \"1 secunda\"\n ]\n , examples (DurationData 30 Minute)\n [ \"jumatate ora\"\n , \"1/2h\"\n , \"treizeci minute\"\n ]\n , examples (DurationData 45 Minute)\n [ \"trei sferturi de or\u00c4\u0192\"\n , \"45min\"\n , \"45 de minute\"\n ]\n , examples (DurationData 12 Week)\n [ \"doi\u00c8\u2122pe saptamanile\"\n , \"doisprezece sapt\u00c4\u0192m\u00c3\u00a2ni\"\n ]\n , examples (DurationData 2 Month)\n [ \"2 luni\"\n ]\n , examples (DurationData 1 Quarter)\n [ \"un trimestru\"\n ]\n ]\n", "num_lines": 53} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Duration.RO.Rules\n ( rules\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Dimensions.Types\nimport Duckling.Duration.Helpers\nimport Duckling.Numeral.Helpers (numberWith)\nimport Duckling.Types\nimport qualified Duckling.Numeral.Types as TNumeral\nimport qualified Duckling.TimeGrain.Types as TG\n\nruleQuarterOfAnHour :: Rule\nruleQuarterOfAnHour = Rule\n { name = \"quarter of an hour\"\n , pattern =\n [ regex \"(1/4\\\\s?(h|or(a|\u00c4\u0192))|sfert de or(a|\u00c4\u0192))\"\n ]\n , prod = \\_ -> Just . Token Duration $ duration TG.Minute 15\n }\n\nruleJumatateDeOra :: Rule\nruleJumatateDeOra = Rule\n { name = \"jumatate de ora\"\n , pattern =\n [ regex \"(1/2\\\\s?(h|or(a|\u00c4\u0192))|jum(a|\u00c4\u0192)tate (de )?or(a|\u00c4\u0192))\"\n ]\n , prod = \\_ -> Just . Token Duration $ duration TG.Minute 30\n }\n\nruleTreiSferturiDeOra :: Rule\nruleTreiSferturiDeOra = Rule\n { name = \"trei sferturi de ora\"\n , pattern =\n [ regex \"(3/4\\\\s?(h|or(a|\u00c4\u0192))|trei sferturi de or(a|\u00c4\u0192))\"\n ]\n , prod = \\_ -> Just . Token Duration $ duration TG.Minute 45\n }\n\nruleOUnitofduration :: Rule\nruleOUnitofduration = Rule\n { name = \"o \"\n , pattern =\n [ regex \"o|un\"\n , dimension TimeGrain\n ]\n , prod = \\case\n (_:Token TimeGrain grain:_) -> Just . Token Duration $ duration grain 1\n _ -> Nothing\n }\n\nruleExactInJurDeDuration :: Rule\nruleExactInJurDeDuration = Rule\n { name = \"exact|in jur de \"\n , pattern =\n [ regex \"(exact|aproximativ|(i|\u00c3\u00ae)n jur de)\"\n , dimension Duration\n ]\n , prod = \\case\n (_:token:_) -> Just token\n _ -> Nothing\n }\n\nruleIntegerDeUnitofduration :: Rule\nruleIntegerDeUnitofduration = Rule\n { name = \" \"\n , pattern =\n [ numberWith TNumeral.value (>= 20)\n , regex \"de\"\n , dimension TimeGrain\n ]\n , prod = \\case\n (Token Numeral TNumeral.NumeralData{TNumeral.value = v}:\n _:\n Token TimeGrain grain:\n _) -> Just . Token Duration . duration grain $ floor v\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleExactInJurDeDuration\n , ruleJumatateDeOra\n , ruleOUnitofduration\n , ruleQuarterOfAnHour\n , ruleTreiSferturiDeOra\n , ruleIntegerDeUnitofduration\n ]\n", "num_lines": 102} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Duration.SV.Corpus\n ( corpus\n ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Duration.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Testing.Types\nimport Duckling.TimeGrain.Types (Grain(..))\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale SV Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (DurationData 1 Second)\n [ \"enkel sek\"\n , \"1 sekund fler\"\n , \"1 sekunder mer\"\n , \"en sekunderna\"\n , \"et sek\"\n , \"ett sek\"\n ]\n , examples (DurationData 30 Minute)\n [ \"1/2 timme\"\n , \"en halv timme\"\n , \"0,5 timmar\"\n , \"30 minuterna\"\n , \"trettio min\"\n ]\n , examples (DurationData 5 Year)\n [ \"5 \u00c3\u00a5r\"\n , \"fem \u00c3\u00a5r\"\n , \"omkring fem \u00c3\u00a5r\"\n , \"ungef\u00c3\u00a4r fem \u00c3\u00a5r\"\n , \"runt fem \u00c3\u00a5r\"\n , \"cirka fem \u00c3\u00a5r\"\n , \"ca fem \u00c3\u00a5r\"\n , \"ca. fem \u00c3\u00a5r\"\n , \"c:a fem \u00c3\u00a5r\"\n ]\n ]\n", "num_lines": 55} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Duration.SV.Rules\n ( rules\n ) where\n\nimport Control.Monad (join)\nimport Data.String\nimport Prelude\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Duration.Helpers\nimport Duckling.Numeral.Helpers (parseInteger)\nimport Duckling.Numeral.Types (NumeralData(..))\nimport Duckling.Regex.Types\nimport Duckling.Types\nimport qualified Duckling.Numeral.Types as TNumeral\nimport qualified Duckling.TimeGrain.Types as TG\n\nruleHalfAnHour :: Rule\nruleHalfAnHour = Rule\n { name = \"half an hour\"\n , pattern =\n [ regex \"(1/2|en halv) timme\"\n ]\n , prod = \\_ -> Just . Token Duration $ duration TG.Minute 30\n }\n\nruleIntegerMoreUnitofduration :: Rule\nruleIntegerMoreUnitofduration = Rule\n { name = \" more \"\n , pattern =\n [ Predicate isNatural\n , dimension TimeGrain\n , regex \"fler|mer\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v}:\n Token TimeGrain grain:\n _) -> Just . Token Duration . duration grain $ floor v\n _ -> Nothing\n }\n\nruleNumeralnumberHours :: Rule\nruleNumeralnumberHours = Rule\n { name = \"number.number hours\"\n , pattern =\n [ regex \"(\\\\d+)\\\\,(\\\\d+)\"\n , regex \"timm(e|ar)?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (h:m:_)):_) -> do\n hh <- parseInteger h\n mnum <- parseInteger m\n let mden = 10 ^ Text.length m\n Just . Token Duration $ minutesFromHourMixedFraction hh mnum mden\n _ -> Nothing\n }\n\nruleIntegerAndAnHalfHours :: Rule\nruleIntegerAndAnHalfHours = Rule\n { name = \" and an half hours\"\n , pattern =\n [ Predicate isNatural\n , regex \"och (en )?halv timme?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v}:_) ->\n Just . Token Duration . duration TG.Minute $ 30 + 60 * floor v\n _ -> Nothing\n }\n\nruleAUnitofduration :: Rule\nruleAUnitofduration = Rule\n { name = \"a \"\n , pattern =\n [ regex \"en|ett?\"\n , dimension TimeGrain\n ]\n , prod = \\tokens -> case tokens of\n (_:Token TimeGrain grain:_) ->\n Just . Token Duration $ duration grain 1\n _ -> Nothing\n }\n\nruleAboutDuration :: Rule\nruleAboutDuration = Rule\n { name = \"about \"\n , pattern =\n [ regex \"(omkring|cirka|ca\\\\.?|c:a|runt|ungef\u00c3\u00a4r)\"\n , dimension Duration\n ]\n , prod = \\tokens -> case tokens of\n (_:token:_) -> Just token\n _ -> Nothing\n }\n\nruleExactlyDuration :: Rule\nruleExactlyDuration = Rule\n { name = \"exactly \"\n , pattern =\n [ regex \"(precis|exakt)\"\n , dimension Duration\n ]\n , prod = \\tokens -> case tokens of\n (_:token:_) -> Just token\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleAUnitofduration\n , ruleAboutDuration\n , ruleExactlyDuration\n , ruleHalfAnHour\n , ruleIntegerAndAnHalfHours\n , ruleIntegerMoreUnitofduration\n , ruleNumeralnumberHours\n ]\n", "num_lines": 129} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Duration.TR.Corpus\n ( corpus\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Duration.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Testing.Types\nimport Duckling.TimeGrain.Types (Grain (..))\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale TR Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (DurationData 1 Second)\n [ \"bir sn\"\n , \"1 saniye\"\n , \"1\\\"\"\n ]\n , examples (DurationData 2 Minute)\n [ \"2 dk\"\n , \"iki dakika\"\n , \"2'\"\n ]\n , examples (DurationData 30 Day)\n [ \"30 g\u00c3\u00bcn\"\n ]\n , examples (DurationData 7 Week)\n [ \"yedi hafta\"\n ]\n , examples (DurationData 1 Month)\n [ \"1 ay\"\n , \"bir ay\"\n ]\n , examples (DurationData 3 Quarter)\n [ \"3 \u00c3\u00a7eyrek y\u00c4\u00b1l\"\n ]\n , examples (DurationData 2 Year)\n [ \"2 y\u00c4\u00b1l\"\n ]\n ]\n", "num_lines": 55} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Duration.TR.Rules\n ( rules\n ) where\n\nimport Control.Monad (join)\nimport Data.String\nimport Prelude\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Duration.Helpers\nimport Duckling.Numeral.Helpers (parseInteger)\nimport Duckling.Numeral.Types (NumeralData (..))\nimport Duckling.Regex.Types\nimport Duckling.Types\nimport qualified Duckling.Numeral.Types as TNumeral\nimport qualified Duckling.TimeGrain.Types as TG\n\nruleDurationQuarterOfAnHour :: Rule\nruleDurationQuarterOfAnHour = Rule\n { name = \"quarter of an hour\"\n , pattern = [ regex \"(1/4\\\\s?sa(at)?|\u00c3\u00a7eyrek saat)\" ]\n , prod = \\_ -> Just . Token Duration $ duration TG.Minute 15\n }\n\nruleDurationHalfAnHour :: Rule\nruleDurationHalfAnHour = Rule\n { name = \"half an hour\"\n , pattern = [regex \"(1/2\\\\s?sa(at)?|yar\\305m saat)\"]\n , prod = \\_ -> Just . Token Duration $ duration TG.Minute 30\n }\n\nruleDurationThreeQuartersOfAnHour :: Rule\nruleDurationThreeQuartersOfAnHour = Rule\n { name = \"three-quarters of an hour\"\n , pattern = [regex \"(3/4\\\\s?sa(at)?|\u00c3\u00bc\u00c3\u00a7 \\231eyrek sa(at)?)\"]\n , prod = \\_ -> Just . Token Duration $ duration TG.Minute 45\n }\n\nruleDurationFortnight :: Rule\nruleDurationFortnight = Rule\n { name = \"fortnight\"\n , pattern = [regex \"iki hafta\"]\n , prod = \\_ -> Just . Token Duration $ duration TG.Day 14\n }\n\nruleNumeralQuotes :: Rule\nruleNumeralQuotes = Rule\n { name = \" + '\\\"\"\n , pattern =\n [ Predicate isNatural\n , regex \"(['\\\"])\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v}:\n Token RegexMatch (GroupMatch (x:_)):\n _) -> case x of\n \"'\" -> Just . Token Duration . duration TG.Minute $ floor v\n \"\\\"\" -> Just . Token Duration . duration TG.Second $ floor v\n _ -> Nothing\n _ -> Nothing\n }\n\nruleDurationDotNumeralHours :: Rule\nruleDurationDotNumeralHours = Rule\n { name = \"number.number hours\"\n , pattern = [regex \"(\\\\d+)(\\\\.|,)(\\\\d+) *sa(at)?\"]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (h:m:_)):_) -> do\n hh <- parseInteger h\n mnum <- parseInteger m\n let mden = 10 ^ Text.length m\n Just . Token Duration $ minutesFromHourMixedFraction hh mnum mden\n _ -> Nothing\n }\n\nruleDurationAndHalfHour :: Rule\nruleDurationAndHalfHour = Rule\n { name = \" and an half hour\"\n , pattern =\n [ Predicate isNatural\n , regex \"bu\u00c3\u00a7uk sa(at)?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v}:_) ->\n Just . Token Duration . duration TG.Minute $ 30 + 60 * floor v\n _ -> Nothing\n }\n\n\nruleDurationPrecision :: Rule\nruleDurationPrecision = Rule\n { name = \" about|exactly\"\n , pattern =\n [ regex \"(yakla\u00c5\u0178\u00c4\u00b1k|tam(\\\\solarak)?)\"\n , dimension Duration\n ]\n , prod = \\tokens -> case tokens of\n (_:token:_) -> Just token\n _ -> Nothing\n }\n\nruleDurationPrecision2 :: Rule\nruleDurationPrecision2 = Rule\n { name = \" about|exactly\"\n , pattern =\n [ dimension Duration\n , regex \"gibi|civar\u00c4\u00b1nda\"\n ]\n , prod = \\case\n (token:_:_) -> Just token\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleDurationQuarterOfAnHour\n , ruleDurationHalfAnHour\n , ruleDurationThreeQuartersOfAnHour\n , ruleDurationFortnight\n , ruleDurationDotNumeralHours\n , ruleDurationAndHalfHour\n , ruleDurationPrecision\n , ruleDurationPrecision2\n , ruleNumeralQuotes\n ]\n", "num_lines": 137} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Duration.UK.Rules\n ( rules ) where\n\nimport Control.Monad (join)\nimport Data.Semigroup ((<>))\nimport Data.String\nimport Prelude\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Duration.Helpers\nimport Duckling.Duration.Types (DurationData(..))\nimport Duckling.Numeral.Helpers (parseInt, parseInteger)\nimport Duckling.Numeral.Types (NumeralData(..))\nimport Duckling.Regex.Types\nimport Duckling.Types\nimport qualified Duckling.Duration.Types as TDuration\nimport qualified Duckling.Numeral.Types as TNumeral\nimport qualified Duckling.TimeGrain.Types as TG\n\nruleHalfAnHour :: Rule\nruleHalfAnHour = Rule\n { name = \"half an hour\"\n , pattern =\n [ regex \"(1/2\\\\s?|\u00d0\u00bf\u00d1\u2013\u00d0\u00b2\\\\s?)\u00d0\u00b3\u00d0\u00be\u00d0\u00b4\u00d0\u00b8\u00d0\u00bd\u00d0\u00b8?\"\n ]\n , prod = \\_ -> Just . Token Duration $ duration TG.Minute 30\n }\n\nruleNumeralnumberHours :: Rule\nruleNumeralnumberHours = Rule\n { name = \"number.number hours\"\n , pattern =\n [ regex \"(\\\\d+)\\\\.(\\\\d+) \u00d0\u00b3\u00d0\u00be\u00d0\u00b4\u00d0\u00b8\u00d0\u00bd\u00d0\u00b8?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (h:m:_)):_) -> do\n hh <- parseInteger h\n mnum <- parseInteger m\n let mden = 10 ^ Text.length m\n Just . Token Duration $ minutesFromHourMixedFraction hh mnum mden\n _ -> Nothing\n }\n\nruleIntegerAndAnHalfHours :: Rule\nruleIntegerAndAnHalfHours = Rule\n { name = \" and an half hours\"\n , pattern =\n [ Predicate isNatural\n , regex \"\u00d0\u00b7 \u00d0\u00bf\u00d0\u00be\u00d0\u00bb\u00d0\u00be\u00d0\u00b2\u00d0\u00b8\u00d0\u00bd\u00d0\u00be\u00d1\u017d \u00d0\u00b3\u00d0\u00be\u00d0\u00b4\u00d0\u00b8\u00d0\u00bd\u00d0\u00b8\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v}:_) ->\n Just . Token Duration . duration TG.Minute $ 30 + 60 * floor v\n _ -> Nothing\n }\n\nruleAboutDuration :: Rule\nruleAboutDuration = Rule\n { name = \"about \"\n , pattern =\n [ regex \"\u00d0\u00b1\u00d0\u00bb\u00d0\u00b8\u00d0\u00b7\u00d1\u0152\u00d0\u00ba\u00d0\u00be\"\n , dimension Duration\n ]\n , prod = \\tokens -> case tokens of\n (_:token:_) -> Just token\n _ -> Nothing\n }\n\nruleExactlyDuration :: Rule\nruleExactlyDuration = Rule\n { name = \"exactly \"\n , pattern =\n [ regex \"\u00d1\u20ac\u00d1\u2013\u00d0\u00b2\u00d0\u00bd\u00d0\u00be\"\n , dimension Duration\n ]\n , prod = \\tokens -> case tokens of\n (_:token:_) -> Just token\n _ -> Nothing\n }\n\nruleDurationHalfATimeGrain :: Rule\nruleDurationHalfATimeGrain = Rule\n { name = \"half a \"\n , pattern =\n [ regex \"(1/2|\u00d0\u00bf\u00d1\u2013\u00d0\u00b2)\"\n , dimension TimeGrain\n ]\n , prod = \\tokens -> case tokens of\n (_:Token TimeGrain grain:_) -> Token Duration <$> nPlusOneHalf grain 0\n _ -> Nothing\n }\n\nruleDurationOneGrainAndHalf :: Rule\nruleDurationOneGrainAndHalf = Rule\n { name = \"one and a hald \"\n , pattern =\n [ regex \"\u00d0\u00bf\u00d1\u2013\u00d0\u00b2\u00d1\u201a\u00d0\u00be\u00d1\u20ac\u00d0\u00b8\"\n , dimension TimeGrain\n ]\n , prod = \\tokens -> case tokens of\n (_:Token TimeGrain grain:_) -> Token Duration <$> nPlusOneHalf grain 1\n _ -> Nothing\n }\n\nruleCompositeDurationCommasAnd :: Rule\nruleCompositeDurationCommasAnd = Rule\n { name = \"composite (with ,/and)\"\n , pattern =\n [ Predicate isNatural\n , dimension TimeGrain\n , regex \",|\u00d1\u2013\"\n , dimension Duration\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v}:\n Token TimeGrain g:\n _:\n Token Duration dd@DurationData{TDuration.grain = dg}:\n _) | g > dg -> Just . Token Duration $ duration g (floor v) <> dd\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleAboutDuration\n , ruleExactlyDuration\n , ruleHalfAnHour\n , ruleIntegerAndAnHalfHours\n , ruleNumeralnumberHours\n , ruleDurationHalfATimeGrain\n , ruleDurationOneGrainAndHalf\n , ruleCompositeDurationCommasAnd\n ]\n", "num_lines": 145} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Email.Corpus\n ( corpus\n , negativeCorpus\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Email.Types\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext, testOptions, allExamples)\n\nnegativeCorpus :: NegativeCorpus\nnegativeCorpus = (testContext, testOptions, examples)\n where\n examples =\n [ \"hey@6\"\n , \"hey@you\"\n ]\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (EmailData \"alice@exAmple.io\")\n [ \"alice@exAmple.io\"\n ]\n , examples (EmailData \"yo+yo@blah.org\")\n [ \"yo+yo@blah.org\"\n ]\n , examples (EmailData \"1234+abc@x.net\")\n [ \"1234+abc@x.net\"\n ]\n , examples (EmailData \"jean-jacques@stuff.co.uk\")\n [ \"jean-jacques@stuff.co.uk\"\n ]\n ]\n", "num_lines": 47} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Email.Rules\n ( rules ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Dimensions.Types\nimport Duckling.Email.Types (EmailData (..))\nimport qualified Duckling.Email.Types as TEmail\nimport Duckling.Regex.Types\nimport Duckling.Types\n\nruleEmail :: Rule\nruleEmail = Rule\n { name = \"email\"\n , pattern =\n [ regex \"([\\\\w\\\\._+-]+@[\\\\w_-]+(\\\\.[\\\\w_-]+)+)\"\n ]\n , prod = \\xs -> case xs of\n (Token RegexMatch (GroupMatch (x:_)):_) ->\n Just $ Token Email EmailData {TEmail.value = x}\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleEmail\n ]\n", "num_lines": 39} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE DeriveAnyClass #-}\n{-# LANGUAGE DeriveGeneric #-}\n{-# LANGUAGE NamedFieldPuns #-}\n{-# LANGUAGE NoRebindableSyntax #-}\n{-# LANGUAGE OverloadedStrings #-}\n{-# LANGUAGE TypeFamilies #-}\n\nmodule Duckling.Email.Types where\n\nimport Control.DeepSeq\nimport Data.Aeson\nimport Data.Hashable\nimport Data.Text (Text)\nimport GHC.Generics\nimport Prelude\n\nimport Duckling.Resolve (Resolve(..))\n\nnewtype EmailData = EmailData { value :: Text }\n deriving (Eq, Generic, Hashable, Ord, Show, NFData)\n\ninstance Resolve EmailData where\n type ResolvedValue EmailData = EmailData\n resolve _ _ x = Just (x, False)\n\ninstance ToJSON EmailData where\n toJSON EmailData {value} = object\n [ \"value\" .= value\n , \"type\" .= (\"value\" :: Text)\n ]\n", "num_lines": 38} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Email.DE.Corpus\n ( corpus\n , negativeCorpus\n ) where\n\nimport Data.String\nimport Prelude\nimport qualified Data.Text as Text\n\nimport Duckling.Email.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncontext :: Context\ncontext = testContext {locale = makeLocale DE Nothing}\n\nnegativeCorpus :: NegativeCorpus\nnegativeCorpus = (context, testOptions, examples)\n where\n examples =\n [ \"fitness at 6.40\"\n , \"class at 12.00\"\n , \"tonight at 9.15\"\n , \" dot 2@abci\"\n , \"x@ dot x\"\n , \"x@ x dot \"\n , \"abc@x dot \"\n , Text.replicate 10000 \"a at a\"\n ]\n\ncorpus :: Corpus\ncorpus = (context, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (EmailData \"alice@exAmple.io\")\n [ \"alice at exAmple.io\"\n ]\n , examples (EmailData \"yo+yo@blah.org\")\n [ \"yo+yo at blah.org\"\n ]\n , examples (EmailData \"1234+abc@x.net\")\n [ \"1234+abc at x.net\"\n ]\n , examples (EmailData \"jean-jacques@stuff.co.uk\")\n [ \"jean-jacques at stuff.co.uk\"\n ]\n , examples (EmailData \"asdf+ab.c@gmail.com\")\n [ \"asdf+ab punkt c at gmail punkt com\"\n ]\n , examples (EmailData \"asdf.k@fb.com\")\n [ \"asdf punkt k@fb punkt com\"\n ]\n ]\n", "num_lines": 65} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Email.DE.Rules\n ( rules ) where\n\nimport Data.String\nimport Prelude\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Email.Types (EmailData (..))\nimport Duckling.Regex.Types\nimport Duckling.Types\nimport qualified Duckling.Email.Types as TEmail\n\nruleEmailSpelledOut :: Rule\nruleEmailSpelledOut = Rule\n { name = \"email spelled out\"\n , pattern =\n [ regex \"([\\\\w_+-]+(?:(?: punkt |\\\\.)[\\\\w_+-]+){0,10})(?: at |@)([a-zA-Z]+(?:(?:\\\\.| punkt )[\\\\w_-]+){1,10})\"\n ]\n , prod = \\xs -> case xs of\n (Token RegexMatch (GroupMatch (m1:m2:_)):_) ->\n Just $ Token Email EmailData\n { TEmail.value = Text.concat [replaceDots m1, \"@\", replaceDots m2] }\n where replaceDots = Text.replace \" punkt \" \".\"\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleEmailSpelledOut\n ]\n", "num_lines": 42} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Email.EN.Corpus\n ( corpus\n , negativeCorpus\n ) where\n\nimport Data.String\nimport Prelude\nimport qualified Data.Text as Text\n\nimport Duckling.Email.Types\nimport Duckling.Testing.Types\n\nnegativeCorpus :: NegativeCorpus\nnegativeCorpus = (testContext, testOptions, examples)\n where\n examples =\n [ \"fitness at 6.40\"\n , \"class at 12.00\"\n , \"tonight at 9.15\"\n , \" dot 2@abci\"\n , \"x@ dot x\"\n , \"x@ x dot \"\n , \"abc@x dot \"\n , Text.replicate 10000 \"a at a\"\n ]\n\ncorpus :: Corpus\ncorpus = (testContext, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (EmailData \"alice@exAmple.io\")\n [ \"alice at exAmple.io\"\n ]\n , examples (EmailData \"yo+yo@blah.org\")\n [ \"yo+yo at blah.org\"\n ]\n , examples (EmailData \"1234+abc@x.net\")\n [ \"1234+abc at x.net\"\n ]\n , examples (EmailData \"jean-jacques@stuff.co.uk\")\n [ \"jean-jacques at stuff.co.uk\"\n ]\n , examples (EmailData \"asdf+ab.c@gmail.com\")\n [ \"asdf+ab dot c at gmail dot com\"\n ]\n , examples (EmailData \"asdf.k@fb.com\")\n [ \"asdf dot k@fb dot com\"\n ]\n ]\n", "num_lines": 60} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Email.EN.Rules\n ( rules ) where\n\nimport Data.String\nimport Prelude\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Email.Types (EmailData (..))\nimport Duckling.Regex.Types\nimport Duckling.Types\nimport qualified Duckling.Email.Types as TEmail\n\nruleEmailSpelledOut :: Rule\nruleEmailSpelledOut = Rule\n { name = \"email spelled out\"\n , pattern =\n [ regex \"([\\\\w_+-]+(?:(?: dot |\\\\.)[\\\\w_+-]+){0,10})(?: at |@)([a-zA-Z]+(?:(?:\\\\.| dot )[\\\\w_-]+){1,10})\"\n ]\n , prod = \\xs -> case xs of\n (Token RegexMatch (GroupMatch (m1:m2:_)):_) ->\n Just $ Token Email EmailData\n { TEmail.value = Text.concat [replaceDots m1, \"@\", replaceDots m2] }\n where replaceDots = Text.replace \" dot \" \".\"\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleEmailSpelledOut\n ]\n", "num_lines": 42} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Email.FR.Corpus\n ( corpus\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Email.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale FR Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (EmailData \"alice@exAmple.io\")\n [ \"alice arobase exAmple.io\"\n ]\n , examples (EmailData \"yo+yo@blah.org\")\n [ \"yo+yo arobase blah.org\"\n ]\n , examples (EmailData \"1234+abc@x.net\")\n [ \"1234+abc arobase x.net\"\n ]\n , examples (EmailData \"jean-jacques@stuff.co.uk\")\n [ \"jean-jacques arobase stuff.co.uk\"\n ]\n ]\n", "num_lines": 40} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Email.FR.Rules\n ( rules ) where\n\nimport Data.String\nimport qualified Data.Text as Text\nimport Prelude\n\nimport Duckling.Dimensions.Types\nimport Duckling.Email.Types (EmailData (..))\nimport qualified Duckling.Email.Types as TEmail\nimport Duckling.Regex.Types\nimport Duckling.Types\n\nruleEmailSpelledOut :: Rule\nruleEmailSpelledOut = Rule\n { name = \"email spelled out\"\n , pattern =\n [ regex \"([\\\\w\\\\._+-]+) arobase ([\\\\w_-]+(\\\\.[\\\\w_-]+)+)\"\n ]\n , prod = \\xs -> case xs of\n (Token RegexMatch (GroupMatch (m1:m2:_)):_) ->\n Just $ Token Email EmailData {TEmail.value = Text.concat [m1, \"@\", m2]}\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleEmailSpelledOut\n ]\n", "num_lines": 40} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Email.IS.Corpus\n ( corpus\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Email.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale IS Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (EmailData \"alice@exAmple.io\")\n [ \"alice ingi exAmple.io\"\n ]\n , examples (EmailData \"yo+yo@blah.org\")\n [ \"yo+yo ingi blah.org\"\n ]\n , examples (EmailData \"1234+abc@x.net\")\n [ \"1234+abc ingi x.net\"\n ]\n , examples (EmailData \"jean-jacques@stuff.co.uk\")\n [ \"jean-jacques ingi stuff.co.uk\"\n ]\n ]\n", "num_lines": 40} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Email.IS.Rules\n ( rules ) where\n\nimport Data.String\nimport qualified Data.Text as Text\nimport Prelude\n\nimport Duckling.Dimensions.Types\nimport Duckling.Email.Types (EmailData (..))\nimport qualified Duckling.Email.Types as TEmail\nimport Duckling.Regex.Types\nimport Duckling.Types\n\nruleEmailSpelledOut :: Rule\nruleEmailSpelledOut = Rule\n { name = \"email spelled out\"\n , pattern =\n [ regex \"([\\\\w\\\\._+-]+) ingi ([\\\\w_-]+(\\\\.[\\\\w_-]+)+)\"\n ]\n , prod = \\xs -> case xs of\n (Token RegexMatch (GroupMatch (m1:m2:_)):_) ->\n Just $ Token Email EmailData {TEmail.value = Text.concat [m1, \"@\", m2]}\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleEmailSpelledOut\n ]\n", "num_lines": 40} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Email.IT.Corpus\n ( corpus\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Email.Types\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale IT Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (EmailData \"alice@exAmple.io\")\n [ \"alice chiocciola exAmple.io\"\n ]\n , examples (EmailData \"yo+yo@blah.org\")\n [ \"yo+yo chiocciola blah.org\"\n ]\n , examples (EmailData \"1234+abc@x.net\")\n [ \"1234+abc chiocciola x.net\"\n ]\n , examples (EmailData \"jean-jacques@stuff.co.uk\")\n [ \"jean-jacques chiocciola stuff.co.uk\"\n ]\n ]\n", "num_lines": 40} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Email.IT.Rules\n ( rules ) where\n\nimport Data.String\nimport qualified Data.Text as Text\nimport Prelude\n\nimport Duckling.Dimensions.Types\nimport Duckling.Email.Types (EmailData (..))\nimport qualified Duckling.Email.Types as TEmail\nimport Duckling.Regex.Types\nimport Duckling.Types\n\nruleEmailSpelledOut :: Rule\nruleEmailSpelledOut = Rule\n { name = \"email spelled out\"\n , pattern =\n [ regex \"([\\\\w\\\\._+-]+) chiocciola ([\\\\w_-]+(\\\\.[\\\\w_-]+)+)\"\n ]\n , prod = \\xs -> case xs of\n (Token RegexMatch (GroupMatch (m1:m2:_)):_) ->\n Just $ Token Email EmailData {TEmail.value = Text.concat [m1, \"@\", m2]}\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleEmailSpelledOut\n ]\n", "num_lines": 40} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Engine.Regex\n ( matchAll\n , matchOnce\n ) where\n\nimport Text.Regex.Base (matchAll, matchOnce)\n", "num_lines": 14} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n{-# LANGUAGE NoRebindableSyntax #-}\n\nmodule Duckling.Numeral.Rules\n ( rules\n ) where\n\nimport Prelude\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers\nimport Duckling.Regex.Types\nimport Duckling.Types\n\nruleIntegerNumeric :: Rule\nruleIntegerNumeric = Rule\n { name = \"integer (numeric)\"\n , pattern =\n [ regex \"(\\\\d{1,18})\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n toInteger <$> parseInt match >>= integer\n _ -> Nothing\n }\n\nruleFractions :: Rule\nruleFractions = Rule\n { name = \"fractional number\"\n , pattern =\n [ regex \"(\\\\d+)/(\\\\d+)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (numerator:denominator:_)):_) -> do\n n <- parseDecimal False numerator\n d <- parseDecimal False denominator\n divide n d >>= notOkForAnyTime\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleIntegerNumeric\n , ruleFractions\n ]\n", "num_lines": 54} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE DeriveAnyClass #-}\n{-# LANGUAGE DeriveGeneric #-}\n{-# LANGUAGE NamedFieldPuns #-}\n{-# LANGUAGE NoRebindableSyntax #-}\n{-# LANGUAGE OverloadedStrings #-}\n{-# LANGUAGE TypeFamilies #-}\n\nmodule Duckling.Numeral.Types where\n\nimport Control.DeepSeq\nimport Data.Aeson\nimport Data.Hashable\nimport Data.Maybe\nimport Data.Text (Text)\nimport GHC.Generics\nimport Prelude\n\nimport Duckling.Resolve\n\ndata NumeralData = NumeralData\n { value :: Double\n , grain :: Maybe Int\n , multipliable :: Bool\n -- Hack until other use cases pop up,\n -- at which point we'll craft a generic solution.\n -- This allows to explicitly flag Numerals that don't work well with Time.\n -- See `ruleTODLatent`. Prevents things like \"at single\", \"dozens o'clock\".\n , okForAnyTime :: Bool\n }\n deriving (Eq, Generic, Hashable, Ord, Show, NFData)\n\ninstance Resolve NumeralData where\n type ResolvedValue NumeralData = NumeralValue\n resolve _ _ NumeralData {value} = Just (NumeralValue {vValue = value}, False)\n\nnewtype NumeralValue = NumeralValue { vValue :: Double }\n deriving (Eq, Show)\n\ninstance ToJSON NumeralValue where\n toJSON (NumeralValue value) = object\n [ \"type\" .= (\"value\" :: Text)\n , \"value\" .= value\n ]\n\ngetIntValue :: Double -> Maybe Int\ngetIntValue x = if rest == 0 then Just int else Nothing\n where\n (int, rest) = properFraction x :: (Int, Double)\n\nisInteger :: Double -> Bool\nisInteger = isJust . getIntValue\n\nisMultiple :: Int -> Double -> Bool\nisMultiple base = isJust . getIntValue . (/ fromIntegral base)\n\nisIntegerBetween :: Double -> Int -> Int -> Bool\nisIntegerBetween x low high = case getIntValue x of\n Just int -> low <= int && int <= high\n Nothing -> False\n", "num_lines": 67} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Numeral.AF.Corpus\n ( corpus\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Locale\nimport Duckling.Numeral.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus =\n ( testContext {locale = makeLocale AF Nothing}\n , testOptions\n , allExamples\n )\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (NumeralValue 0)\n [ \"nul\"\n , \"geen\"\n , \"niks\"\n ]\n , examples (NumeralValue 1)\n [ \"een\"\n ]\n , examples (NumeralValue 2)\n [ \"twee\"\n ]\n , examples (NumeralValue 3)\n [ \"drie\"\n ]\n , examples (NumeralValue 4)\n [ \"vier\"\n ]\n , examples (NumeralValue 5)\n [ \"vyf\"\n ]\n , examples (NumeralValue 6)\n [ \"ses\"\n ]\n , examples (NumeralValue 7)\n [ \"sewe\"\n ]\n , examples (NumeralValue 8)\n [ \"agt\"\n , \"ag\"\n ]\n , examples (NumeralValue 9)\n [ \"nege\"\n ]\n , examples (NumeralValue 10)\n [ \"tien\"\n ]\n , examples (NumeralValue 11)\n [ \"elf\"\n ]\n , examples (NumeralValue 12)\n [ \"twaalf\"\n , \"dosyn\"\n ]\n , examples (NumeralValue 14)\n [ \"veertien\"\n ]\n , examples (NumeralValue 15)\n [ \"vyftien\"\n ]\n , examples (NumeralValue 16)\n [ \"sestien\"\n ]\n , examples (NumeralValue 17)\n [ \"sewentien\"\n ]\n , examples (NumeralValue 19)\n [ \"negentien\"\n , \"neentien\"\n ]\n , examples (NumeralValue 20)\n [ \"twintig\"\n ]\n , examples (NumeralValue 22)\n [ \"twee en twintig\"\n ]\n , examples (NumeralValue 24)\n [ \"vier en twintig\"\n ]\n , examples (NumeralValue 26)\n [ \"ses en twintig\"\n ]\n , examples (NumeralValue 28)\n [ \"agt en twintig\"\n ]\n , examples (NumeralValue 33)\n [ \"drie en dertig\"\n ]\n , examples (NumeralValue 34)\n [ \"vier en dertig\"\n ]\n , examples (NumeralValue 50)\n [ \"vyftig\"\n ]\n , examples (NumeralValue 55)\n [ \"vyf en vyftig\"\n ]\n , examples (NumeralValue 1.1)\n [ \"1,1\"\n , \"1,10\"\n , \"01,10\"\n ]\n , examples (NumeralValue 0.77)\n [ \"0,77\"\n , \",77\"\n ]\n , examples (NumeralValue 300)\n [ \"3 honderd\"\n , \"drie honderd\"\n ]\n , examples (NumeralValue 5000)\n [ \"5 duisend\"\n , \"vyf duisend\"\n ]\n , examples (NumeralValue 144)\n [ \"een honderd vier en veertig\"\n , \"honderd vier en veertig\"\n ]\n , examples (NumeralValue 122)\n [ \"een honderd twee en twintig\"\n , \"honderd twee en twintig\"\n ]\n , examples (NumeralValue 20000)\n [ \"twintig duisend\"\n ]\n , examples (NumeralValue 0.2)\n [ \"0,2\"\n , \"1/5\"\n , \"2/10\"\n , \"3/15\"\n , \"20/100\"\n ]\n ]\n", "num_lines": 153} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n{-# LANGUAGE NoRebindableSyntax #-}\n\nmodule Duckling.Numeral.AF.Rules\n ( rules\n ) where\n\nimport Control.Applicative ((<|>))\nimport Data.HashMap.Strict (HashMap)\nimport Data.Maybe\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers\nimport Duckling.Numeral.Types (NumeralData(..))\nimport Duckling.Regex.Types\nimport Duckling.Types\nimport qualified Duckling.Numeral.Types as TNumeral\n\nzeroAndTenMap :: HashMap Text Integer\nzeroAndTenMap = HashMap.fromList\n [ ( \"nul\" , 0 )\n , ( \"geen\", 0 )\n , ( \"niks\", 0 )\n , ( \"zero\", 0 )\n , ( \"tien\", 10 )\n ]\n\noneToNineMap :: HashMap Text Integer\noneToNineMap = HashMap.fromList\n [ ( \"een\" , 1 )\n , ( \"twee\", 2 )\n , ( \"drie\", 3 )\n , ( \"vier\", 4 )\n , ( \"vyf\" , 5 )\n , ( \"ses\" , 6 )\n , ( \"sewe\", 7 )\n , ( \"agt\" , 8 )\n , ( \"ag\" , 8 )\n , ( \"nege\", 9 )\n ]\n\nruleNumeral :: Rule\nruleNumeral = Rule\n { name = \"number (0..10)\"\n , pattern =\n [ regex . Text.unpack $\n Text.concat [ \"(\", Text.intercalate \"|\"\n ((HashMap.keys zeroAndTenMap) ++ (HashMap.keys oneToNineMap)), \")\" ]\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n let x = Text.toLower match in\n (HashMap.lookup x oneToNineMap >>= integer) <|>\n (HashMap.lookup x zeroAndTenMap >>= integer)\n _ -> Nothing\n }\n\nelevenToNineteenMap :: HashMap Text Integer\nelevenToNineteenMap = HashMap.fromList\n [ ( \"elf\" , 11 )\n , ( \"twaalf\" , 12 )\n , ( \"dertien\" , 13 )\n , ( \"veertien\" , 14 )\n , ( \"vyftien\" , 15 )\n , ( \"sestien\" , 16 )\n , ( \"sewentien\", 17 )\n , ( \"agtien\" , 18 )\n , ( \"negentien\", 19 )\n , ( \"neentien\" , 19 )\n ]\n\nruleElevenToNineteen :: Rule\nruleElevenToNineteen = Rule\n { name = \"number (11..19)\"\n , pattern =\n [ regex \"(elf|twaalf|dertien|veertien|vyftien|sestien|sewentien|agtien|neg?entien)\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) elevenToNineteenMap >>= integer\n _ -> Nothing\n }\n\ntensMap :: HashMap Text Integer\ntensMap = HashMap.fromList\n [ ( \"twin\" , 20 )\n , ( \"der\" , 30 )\n , ( \"veer\" , 40 )\n , ( \"vyf\" , 50 )\n , ( \"ses\" , 60 )\n , ( \"sewen\", 70 )\n , ( \"tag\" , 80 )\n , ( \"negen\", 90 )\n , ( \"neen\" , 90 )\n ]\n\nruleTens :: Rule\nruleTens = Rule\n { name = \"integer (20,30..90)\"\n , pattern =\n [ regex \"(twin|der|veer|vyf|ses|sewen|tag|neg?en)tig\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) tensMap >>= integer\n _ -> Nothing\n }\n\nruleCompositeTens :: Rule\nruleCompositeTens = Rule\n { name = \"integer ([3-9][1-9])\"\n , pattern =\n [ Predicate $ numberBetween 1 10\n , regex \"en\"\n , oneOf [20, 30..90]\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = units}:\n _:\n Token Numeral NumeralData{TNumeral.value = tens}:\n _) -> double $ tens + units\n _ -> Nothing\n }\n\nruleDecimals :: Rule\nruleDecimals = Rule\n { name = \"decimal number\"\n , pattern =\n [ regex \"(\\\\d*\\\\,\\\\d+)\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):_) -> parseDecimal False match\n _ -> Nothing\n }\n\nrulePowersOfTen :: Rule\nrulePowersOfTen = Rule\n { name = \"powers of tens\"\n , pattern =\n [ regex \"(honderd|duisend)\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of\n \"honderd\" -> double 1e2 >>= withGrain 2 >>= withMultipliable\n \"duisend\" -> double 1e3 >>= withGrain 3 >>= withMultipliable\n _ -> Nothing\n _ -> Nothing\n }\n\nruleDozen :: Rule\nruleDozen = Rule\n { name = \"a dozen of\"\n , pattern =\n [ regex \"dosyn\"\n ]\n , prod = \\_ -> integer 12 >>= withMultipliable >>= notOkForAnyTime\n }\n\nruleSum :: Rule\nruleSum = Rule\n { name = \"intersect 2 numbers\"\n , pattern =\n [ Predicate $ and . sequence [hasGrain, isPositive]\n , Predicate $ and . sequence [not . isMultipliable, isPositive]\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = val1, TNumeral.grain = Just g}:\n Token Numeral NumeralData{TNumeral.value = val2}:\n _) | (10 ** fromIntegral g) > val2 -> double $ val1 + val2\n _ -> Nothing\n }\n\nruleMultiply :: Rule\nruleMultiply = Rule\n { name = \"compose by multiplication\"\n , pattern =\n [ dimension Numeral\n , Predicate isMultipliable\n ]\n , prod = \\case\n (token1:token2:_) -> multiply token1 token2\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleNumeral\n , ruleDozen\n , ruleDecimals\n , rulePowersOfTen\n , ruleElevenToNineteen\n , ruleTens\n , ruleCompositeTens\n , ruleSum\n , ruleMultiply\n ]\n", "num_lines": 211} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\nmodule Duckling.Numeral.AR.Helpers\n ( digitsMap\n , numeralToStringMap\n , parseArabicDoubleAsText\n , parseArabicDoubleFromText\n , parseArabicIntAsText\n , parseArabicIntegerFromText\n ) where\n\nimport Control.Monad (join)\nimport Data.HashMap.Strict (HashMap)\nimport Data.Maybe (mapMaybe)\nimport Data.String\nimport Data.Text (Text)\nimport Duckling.Numeral.Helpers\n ( parseDouble\n , parseInteger\n )\nimport Prelude\n\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\n\nnumeralToStringMap :: HashMap Char String\nnumeralToStringMap =\n HashMap.fromList\n [ ('\u00d9\u00a0', \"0\")\n , ('\u00d9\u00a1', \"1\")\n , ('\u00d9\u00a2', \"2\")\n , ('\u00d9\u00a3', \"3\")\n , ('\u00d9\u00a4', \"4\")\n , ('\u00d9\u00a5', \"5\")\n , ('\u00d9\u00a6', \"6\")\n , ('\u00d9\u00a7', \"7\")\n , ('\u00d9\u00a8', \"8\")\n , ('\u00d9\u00a9', \"9\")\n ]\n\ndigitsMap :: HashMap Text Integer\ndigitsMap =\n HashMap.fromList\n [ (\"\u00d8\u00b9\u00d8\u00b4\u00d8\u00b1\", 2)\n , (\"\u00d8\u00ab\u00d9\u201e\u00d8\u00a7\u00d8\u00ab\", 3)\n , (\"\u00d8\u00a7\u00d8\u00b1\u00d8\u00a8\u00d8\u00b9\", 4)\n , (\"\u00d8\u00a3\u00d8\u00b1\u00d8\u00a8\u00d8\u00b9\", 4)\n , (\"\u00d8\u00ae\u00d9\u2026\u00d8\u00b3\", 5)\n , (\"\u00d8\u00b3\u00d8\u00aa\", 6)\n , (\"\u00d8\u00b3\u00d8\u00a8\u00d8\u00b9\", 7)\n , (\"\u00d8\u00ab\u00d9\u2026\u00d8\u00a7\u00d9\u2020\", 8)\n , (\"\u00d8\u00aa\u00d8\u00b3\u00d8\u00b9\", 9)\n ]\n\nparseArabicIntAsText :: Text -> Text\nparseArabicIntAsText =\n Text.pack\n . join\n . mapMaybe (`HashMap.lookup` numeralToStringMap)\n . Text.unpack\n\nparseArabicIntegerFromText :: Text -> Maybe Integer\nparseArabicIntegerFromText = parseInteger . parseArabicIntAsText\n\nparseArabicDoubleAsText :: Text -> Text\nparseArabicDoubleAsText =\n Text.pack\n . join\n . mapMaybe (`HashMap.lookup` HashMap.insert '\u00d9\u00ab' \".\" numeralToStringMap)\n . Text.unpack\n\nparseArabicDoubleFromText :: Text -> Maybe Double\nparseArabicDoubleFromText = parseDouble . parseArabicDoubleAsText\n", "num_lines": 81} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\nmodule Duckling.Numeral.AR.EG.Helpers\n ( digitsMap\n , numeralToStringMap\n , parseArabicDoubleAsText\n , parseArabicDoubleFromText\n , parseArabicIntAsText\n , parseArabicIntegerFromText\n ) where\n\nimport Control.Monad (join)\nimport Data.HashMap.Strict (HashMap)\nimport Data.Maybe (mapMaybe)\nimport Data.String\nimport Data.Text (Text)\nimport Duckling.Numeral.Helpers\n ( parseDouble\n , parseInteger\n )\nimport Prelude\n\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\n\nnumeralToStringMap :: HashMap Char String\nnumeralToStringMap =\n HashMap.fromList\n [ ('\u00d9\u00a0', \"0\")\n , ('\u00d9\u00a1', \"1\")\n , ('\u00d9\u00a2', \"2\")\n , ('\u00d9\u00a3', \"3\")\n , ('\u00d9\u00a4', \"4\")\n , ('\u00d9\u00a5', \"5\")\n , ('\u00d9\u00a6', \"6\")\n , ('\u00d9\u00a7', \"7\")\n , ('\u00d9\u00a8', \"8\")\n , ('\u00d9\u00a9', \"9\")\n ]\n\ndigitsMap :: HashMap Text Integer\ndigitsMap =\n HashMap.fromList\n [ (\"\u00d8\u00a7\u00d8\u00aa\u00d9\u2020\u00d9\u0160\u00d9\u2020\", 2)\n , (\"\u00d8\u00aa\u00d9\u201e\u00d8\u00a7\u00d8\u00aa\", 3)\n , (\"\u00d8\u00a7\u00d8\u00b1\u00d8\u00a8\u00d8\u00b9\", 4)\n , (\"\u00d8\u00a3\u00d8\u00b1\u00d8\u00a8\u00d8\u00b9\", 4)\n , (\"\u00d8\u00ae\u00d9\u2026\u00d8\u00b3\", 5)\n , (\"\u00d8\u00b3\u00d8\u00aa\", 6)\n , (\"\u00d8\u00b3\u00d8\u00a8\u00d8\u00b9\", 7)\n , (\"\u00d8\u00aa\u00d9\u2026\u00d8\u00a7\u00d9\u2020\", 8)\n , (\"\u00d8\u00aa\u00d8\u00b3\u00d8\u00b9\", 9)\n ]\n\nparseArabicIntAsText :: Text -> Text\nparseArabicIntAsText =\n Text.pack\n . join\n . mapMaybe (`HashMap.lookup` numeralToStringMap)\n . Text.unpack\n\nparseArabicIntegerFromText :: Text -> Maybe Integer\nparseArabicIntegerFromText = parseInteger . parseArabicIntAsText\n\nparseArabicDoubleAsText :: Text -> Text\nparseArabicDoubleAsText =\n Text.pack\n . join\n . mapMaybe (`HashMap.lookup` HashMap.insert '\u00d9\u00ab' \".\" numeralToStringMap)\n . Text.unpack\n\nparseArabicDoubleFromText :: Text -> Maybe Double\nparseArabicDoubleFromText = parseDouble . parseArabicDoubleAsText\n", "num_lines": 81} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Numeral.CA.Corpus (corpus) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Locale\nimport Duckling.Numeral.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus =\n (testContext { locale = makeLocale CA Nothing }, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples =\n concat\n [ examples (NumeralValue 1)\n [ \"1\"\n , \"u\"\n , \"un\"\n , \"una\"\n ]\n , examples (NumeralValue 11)\n [ \"onze\"\n ]\n , examples (NumeralValue 12)\n [ \"dotze\"\n ]\n , examples (NumeralValue 13)\n [ \"tretze\"\n ]\n , examples (NumeralValue 14)\n [ \"catorze\"\n ]\n , examples (NumeralValue 15)\n [ \"quinze\"\n ]\n , examples (NumeralValue 16)\n [ \"setze\"\n ]\n , examples (NumeralValue 17)\n [ \"disset\"\n , \"d\u00c3\u00a8sset\"\n ]\n , examples (NumeralValue 18)\n [ \"divuit\"\n , \"dihuit\"\n , \"devuit\"\n ]\n , examples (NumeralValue 19)\n [ \"dinou\"\n , \"d\u00c3\u00a8nou\"\n , \"denou\"\n ]\n , examples (NumeralValue 20)\n [ \"vint\"\n ]\n , examples (NumeralValue 21)\n [ \"vint-i-un\"\n , \"vint i un\"\n ]\n , examples (NumeralValue 22)\n [ \"vint-i-dos\"\n , \"vint i dos\"\n ]\n , examples (NumeralValue 23)\n [ \"vint-i-tres\"\n , \"vint i tres\"\n ]\n , examples (NumeralValue 37)\n [ \"trenta-set\"\n ]\n , examples (NumeralValue 40)\n [ \"quaranta\"\n ]\n , examples (NumeralValue 70)\n [ \"setanta\"\n ]\n , examples (NumeralValue 78)\n [ \"Setanta-vuit\"\n ]\n , examples (NumeralValue 80)\n [ \"vuitanta\"\n ]\n , examples (NumeralValue 33)\n [ \"33\"\n , \"trenta-tres\"\n , \"trenta-3\"\n ]\n , examples (NumeralValue 100000)\n [ \"100000\"\n , \"100K\"\n , \"100k\"\n ]\n , examples (NumeralValue 300)\n [ \"tres-cents\"\n ]\n , examples (NumeralValue 243)\n [ \"243\"\n ]\n , examples (NumeralValue 85)\n [ \"vuitanta-cinc\"\n ]\n , examples (NumeralValue 3000000)\n [ \"3M\"\n , \"3000K\"\n , \"3000000\"\n ]\n , examples (NumeralValue 1200000)\n [ \"1200000\"\n , \"1200K\"\n ]\n , examples (NumeralValue (-1200000))\n [ \"-1200000\"\n , \"-1200K\"\n ]\n , examples (NumeralValue 1.5)\n [ \"1 coma cinc\"\n , \"una coma cinc\"\n , \"u coma cinc\"\n ]\n , examples (NumeralValue 1)\n [ \"zero u\"\n , \"zero un\"\n ]\n , examples (NumeralValue 2)\n [ \"zero dos\"\n ]\n , examples (NumeralValue 3)\n [ \"zero tres\"\n ]\n , examples (NumeralValue 4)\n [ \"zero quatre\"\n ]\n , examples (NumeralValue 5)\n [ \"zero cinc\"\n ]\n , examples (NumeralValue 6)\n [ \"zero sis\"\n ]\n , examples (NumeralValue 7)\n [ \"zero set\"\n ]\n , examples (NumeralValue 8)\n [ \"zero vuit\"\n ]\n , examples (NumeralValue 9)\n [ \"zero nou\"\n ]\n ]\n\n-- Ull, revisar la xifra amb decimals\n", "num_lines": 163} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Numeral.CA.Rules (rules) where\n\nimport Data.HashMap.Strict (HashMap)\nimport qualified Data.HashMap.Strict as HashMap\nimport Data.Maybe\nimport Data.String\nimport Data.Text (Text)\nimport qualified Data.Text as Text\nimport Prelude\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers\nimport Duckling.Numeral.Types (NumeralData(..))\nimport qualified Duckling.Numeral.Types as TNumeral\nimport Duckling.Regex.Types\nimport Duckling.Types\n\nzeroToFifteenMap :: HashMap Text Integer\nzeroToFifteenMap =\n HashMap.fromList\n [ (\"zero\", 0)\n , (\"u\", 1)\n , (\"un\", 1)\n , (\"una\", 1)\n , (\"dos\", 2)\n , (\"dues\", 2)\n , (\"tres\", 3)\n , (\"quatre\", 4)\n , (\"cinc\", 5)\n , (\"sis\", 6)\n , (\"set\", 7)\n , (\"vuit\", 8)\n , (\"nou\", 9)\n , (\"deu\", 10)\n , (\"onze\", 11)\n , (\"dotze\", 12)\n , (\"tretze\", 13)\n , (\"catorze\", 14)\n , (\"quinze\", 15)\n ]\n\nruleZeroToFifteen :: Rule\nruleZeroToFifteen = Rule\n { name = \"number (0..15)\"\n , pattern =\n [ regex\n \"(zero|u(na|n)?|d(o|ue)s|tres|quatre|cinc|sis|set|vuit|nou|deu|onze|dotze|tretze|catorze|quinze)\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) zeroToFifteenMap >>= integer\n _ -> Nothing\n }\n\nruleNumeralsPrefixWithNegativeOrMinus :: Rule\nruleNumeralsPrefixWithNegativeOrMinus = Rule\n { name = \"numbers prefix with -, negative or minus\"\n , pattern = [regex \"-|menys\", Predicate isPositive]\n , prod = \\case\n (_ : Token Numeral NumeralData { TNumeral.value = v } : _) ->\n double $ negate v\n _ -> Nothing\n }\n\ntensMap :: HashMap Text Integer\ntensMap =\n HashMap.fromList\n [ (\"vint\", 20)\n , (\"trenta\", 30)\n , (\"quaranta\", 40)\n , (\"cinquanta\", 50)\n , (\"seixanta\", 60)\n , (\"setanta\", 70)\n , (\"vuitanta\", 80)\n , (\"noranta\", 90)\n ]\n\nruleTens :: Rule\nruleTens = Rule\n { name = \"number (20..90)\"\n , pattern =\n [ regex\n \"(vint|(tre|quara|cinqua|seixa|seta|vuita|nora)nta)\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)) : _) ->\n HashMap.lookup (Text.toLower match) tensMap >>= integer\n _ -> Nothing\n }\n\nsixteenToTwentyNineMap :: HashMap Text Integer\nsixteenToTwentyNineMap =\n HashMap.fromList\n [ (\"setze\", 16)\n , (\"disset\", 17)\n , (\"d\u00c3\u00a8sset\", 17)\n , (\"devuit\", 18)\n , (\"divuit\", 18)\n , (\"dihuit\", 18)\n , (\"dinou\", 19)\n , (\"d\u00c3\u00a8nou\", 19)\n , (\"denou\", 19)\n , (\"vint-i-u\", 21)\n , (\"vint-i-una\", 21)\n , (\"vint-i-dos\", 22)\n , (\"vint-i-tres\", 23)\n , (\"vint-i-quatre\", 24)\n , (\"vint-i-cinc\", 25)\n , (\"vint-i-sis\", 26)\n , (\"vint-i-set\", 27)\n , (\"vint-i-vuit\", 28)\n , (\"vint-i-nou\", 29)\n ]\n\nruleLowerTensWithOnes :: Rule\nruleLowerTensWithOnes = Rule\n { name = \"number (16..19 21..29)\"\n , pattern =\n [ regex\n \"(setze|d(i|e|\u00c3\u00a8)sset|d(e|i)(v|h)uit|d(i|e|\u00c3\u00a8)nou|vint-i-u(na)?|vint-i-dos|vint-i-tres|vint-i-quatre|vint-i-cinc|vint-i-sis|vint-i-set|vint-i-vuit|vint-i-nou)\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) sixteenToTwentyNineMap >>= integer\n _ -> Nothing\n }\n\nruleHigherTensWithOnes :: Rule\nruleHigherTensWithOnes = Rule\n { name = \"number (31..39 41..49 51..59 61..69 71..79 81..89 91..99)\"\n , pattern =\n [ oneOf [30, 40, 50, 60, 70, 80, 90]\n , regex \"-\"\n , Predicate $ numberBetween 1 9\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = v1}:\n _:\n Token Numeral NumeralData{TNumeral.value = v2}:\n _) -> double $ v1 + v2\n _ -> Nothing\n }\n\nruleNumeralsSuffixesKMG :: Rule\nruleNumeralsSuffixesKMG = Rule\n { name = \"numbers suffixes (K, M, G)\"\n , pattern = [dimension Numeral, regex \"([kmg])(?=[\\\\W\\\\$\u00e2\u201a\u00ac]|$)\"]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = v}:\n Token RegexMatch (GroupMatch (match:_)):\n _) ->\n case Text.toLower match of\n \"k\" -> double $ v * 1e3\n \"m\" -> double $ v * 1e6\n \"g\" -> double $ v * 1e9\n _ -> Nothing\n _ -> Nothing\n }\n\noneHundredToThousandMap :: HashMap Text Integer\noneHundredToThousandMap =\n HashMap.fromList\n [ (\"cent\", 100)\n , (\"cents\", 100)\n , (\"dos-cents\", 200)\n , (\"tres-cents\", 300)\n , (\"quatre-cents\", 400)\n , (\"cinc-cents\", 500)\n , (\"sis-cents\", 600)\n , (\"set-cents\", 700)\n , (\"vuit-cents\", 800)\n , (\"nou-cents\", 900)\n , (\"mil\", 1000)\n ]\n\nruleTwenties :: Rule\nruleTwenties = Rule\n { name = \"number (21..29)\"\n , pattern =\n [ oneOf [20]\n , regex \"(-i-| i )\"\n , Predicate $ numberBetween 1 10\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = v1}:\n _:\n Token Numeral NumeralData{TNumeral.value = v2}:\n _) -> double $ v1 + v2\n _ -> Nothing\n }\n\nruleHundreds :: Rule\nruleHundreds = Rule\n { name = \"number 100..1000 \"\n , pattern =\n [ regex\n \"(cent(s)?|dos-cents|tres-cents|quatre-cents|cinc-cents|sis-cents|set-cents|vuit-cents|nou-cents|mil)\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) oneHundredToThousandMap >>= integer\n _ -> Nothing\n }\n\n-- Afegeixo regex \"-\" perque les centenes s'escriuen dos-cent, tres-cent\nruleNumerals :: Rule\nruleNumerals = Rule\n { name = \"numbers 200..999\"\n , pattern =\n [ Predicate $ numberBetween 2 10\n , regex \"-\"\n , numberWith TNumeral.value (== 100)\n , Predicate $ numberBetween 0 100\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = v1}:\n _:\n Token Numeral NumeralData{TNumeral.value = v2}:\n _) -> double $ 100 * v1 + v2\n _ -> Nothing\n }\n\nruleNumeralDotNumeral :: Rule\nruleNumeralDotNumeral = Rule\n { name = \"number dot number\"\n , pattern = [dimension Numeral, regex \"coma\", Predicate $ not . hasGrain]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = v1}:\n _:\n Token Numeral NumeralData{TNumeral.value = v2}:\n _) -> double $ v1 + decimalsToDouble v2\n _ -> Nothing\n }\n\nruleBelowTenWithTwoDigits :: Rule\nruleBelowTenWithTwoDigits = Rule\n { name = \"integer (0-9) with two digits\"\n , pattern =\n [ regex \"zero|0\"\n , Predicate $ numberBetween 1 10\n ]\n , prod = \\case\n (_:Token Numeral NumeralData{TNumeral.value = v}:_) -> double v\n _ -> Nothing\n }\n\nruleDecimalWithThousandsSeparator :: Rule\nruleDecimalWithThousandsSeparator = Rule\n { name = \"decimal with thousands separator .\"\n , pattern = [regex \"(\\\\d+(\\\\.\\\\d\\\\d\\\\d)+,\\\\d+)\"]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n let fmt = Text.replace \",\" \".\" . Text.replace \".\" Text.empty $ match\n in parseDouble fmt >>= double\n _ -> Nothing\n }\n\nruleDecimalNumeral :: Rule\nruleDecimalNumeral = Rule\n { name = \"decimal number ,\"\n , pattern = [regex \"(\\\\d*,\\\\d+)\"]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n parseDecimal False match\n _ -> Nothing\n }\n\nruleIntegerWithThousandsSeparator :: Rule\nruleIntegerWithThousandsSeparator = Rule\n { name = \"integer with thousands separator .\"\n , pattern = [regex \"(\\\\d{1,3}(\\\\.\\\\d\\\\d\\\\d){1,5})\"]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n parseDouble (Text.replace \".\" Text.empty match) >>= double\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleBelowTenWithTwoDigits\n , ruleZeroToFifteen\n , ruleTens\n , ruleTwenties\n , ruleLowerTensWithOnes\n , ruleHigherTensWithOnes\n , ruleHundreds\n\n , ruleNumeralDotNumeral\n , ruleNumerals\n , ruleNumeralsPrefixWithNegativeOrMinus\n , ruleNumeralsSuffixesKMG\n , ruleDecimalNumeral\n , ruleDecimalWithThousandsSeparator\n , ruleIntegerWithThousandsSeparator\n ]\n", "num_lines": 307} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Numeral.DA.Corpus\n ( corpus ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Locale\nimport Duckling.Numeral.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale DA Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (NumeralValue 0)\n [ \"0\"\n , \"nul\"\n ]\n , examples (NumeralValue 1)\n [ \"1\"\n , \"\u00c3\u00a9n\"\n , \"en\"\n , \"\u00c3\u00a9t\"\n , \"et\"\n ]\n , examples (NumeralValue 2)\n [ \"2\"\n , \"to\"\n , \"et par\"\n ]\n , examples (NumeralValue 14)\n [ \"14\"\n , \"fjorten\"\n ]\n , examples (NumeralValue 16)\n [ \"16\"\n , \"seksten\"\n ]\n , examples (NumeralValue 17)\n [ \"17\"\n , \"sytten\"\n ]\n , examples (NumeralValue 18)\n [ \"18\"\n , \"Atten\"\n ]\n , examples (NumeralValue 1.1)\n [ \"1,1\"\n , \"1,10\"\n , \"01,10\"\n ]\n , examples (NumeralValue 0.77)\n [ \"0,77\"\n , \",77\"\n ]\n , examples (NumeralValue 100000)\n [ \"100.000\"\n , \"100000\"\n , \"100K\"\n , \"100k\"\n ]\n , examples (NumeralValue 3000000)\n [ \"3M\"\n , \"3000K\"\n , \"3000000\"\n , \"3.000.000\"\n ]\n , examples (NumeralValue 1200000)\n [ \"1.200.000\"\n , \"1200000\"\n , \"1,2M\"\n , \"1200K\"\n , \",0012G\"\n ]\n , examples (NumeralValue (-1200000))\n [ \"- 1.200.000\"\n , \"-1200000\"\n , \"minus 1.200.000\"\n , \"negativ 1200000\"\n , \"-1,2M\"\n , \"-1200K\"\n , \"-,0012G\"\n ]\n , examples (NumeralValue 5000)\n [ \"5 tusind\"\n , \"fem tusinde\"\n , \"fem Tusind\"\n ]\n ]\n", "num_lines": 101} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Numeral.DA.Rules\n ( rules\n ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport Data.Maybe\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers\nimport Duckling.Numeral.Types (NumeralData (..))\nimport Duckling.Regex.Types\nimport Duckling.Types\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleNumeralsPrefixWithNegativeOrMinus :: Rule\nruleNumeralsPrefixWithNegativeOrMinus = Rule\n { name = \"numbers prefix with -, negative or minus\"\n , pattern =\n [ regex \"-|minus|negativ\"\n , Predicate isPositive\n ]\n , prod = \\tokens -> case tokens of\n (_:Token Numeral NumeralData{TNumeral.value = v}:_) ->\n double $ v * (-1)\n _ -> Nothing\n }\n\nruleFew :: Rule\nruleFew = Rule\n { name = \"few\"\n , pattern =\n [ regex \"(nogle )?f\u00c3\u00a5\"\n ]\n , prod = \\_ -> integer 3\n }\n\nruleTen :: Rule\nruleTen = Rule\n { name = \"ten\"\n , pattern =\n [ regex \"ti\"\n ]\n , prod = \\_ -> integer 10 >>= withGrain 1\n }\n\nruleDecimalWithThousandsSeparator :: Rule\nruleDecimalWithThousandsSeparator = Rule\n { name = \"decimal with thousands separator\"\n , pattern =\n [ regex \"(\\\\d+(\\\\.\\\\d\\\\d\\\\d)+\\\\,\\\\d+)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n parseDouble (Text.replace \".\" Text.empty match) >>= double\n _ -> Nothing\n }\n\nruleDecimalNumeral :: Rule\nruleDecimalNumeral = Rule\n { name = \"decimal number\"\n , pattern =\n [ regex \"(\\\\d*,\\\\d+)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n parseDecimal False match\n _ -> Nothing\n }\n\nruleInteger3 :: Rule\nruleInteger3 = Rule\n { name = \"integer 21..99\"\n , pattern =\n [ oneOf [20, 30 .. 90]\n , Predicate $ numberBetween 1 10\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v1}:\n Token Numeral NumeralData{TNumeral.value = v2}:\n _) -> double $ v1 + v2\n _ -> Nothing\n }\n\nruleSingle :: Rule\nruleSingle = Rule\n { name = \"single\"\n , pattern =\n [ regex \"enkelt\"\n ]\n , prod = \\_ -> integer 1 >>= withGrain 1\n }\n\nruleIntersect :: Rule\nruleIntersect = Rule\n { name = \"intersect\"\n , pattern =\n [ Predicate hasGrain\n , Predicate $ and . sequence [not . isMultipliable, isPositive]\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = val1, TNumeral.grain = Just g}:\n Token Numeral NumeralData{TNumeral.value = val2}:\n _) | (10 ** fromIntegral g) > val2 -> double $ val1 + val2\n _ -> Nothing\n }\n\nruleNumeralsSuffixesKMG :: Rule\nruleNumeralsSuffixesKMG = Rule\n { name = \"numbers suffixes (K, M, G)\"\n , pattern =\n [ dimension Numeral\n , regex \"([kmg])(?=[\\\\W\\\\$\u00e2\u201a\u00ac]|$)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v}:\n Token RegexMatch (GroupMatch (match:_)):\n _) -> case Text.toLower match of\n \"k\" -> double $ v * 1e3\n \"m\" -> double $ v * 1e6\n \"g\" -> double $ v * 1e9\n _ -> Nothing\n _ -> Nothing\n }\n\nrulePowersOfTen :: Rule\nrulePowersOfTen = Rule\n { name = \"powers of tens\"\n , pattern =\n [ regex \"(hundrede?|tohundrede|tusinde?|totusinde|million(er)?)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of\n \"hundred\" -> double 1e2 >>= withGrain 2 >>= withMultipliable\n \"hundrede\" -> double 1e2 >>= withGrain 2 >>= withMultipliable\n \"tohundrede\" -> double (2 * 1e2) >>= withGrain 2 >>= withMultipliable\n \"tusind\" -> double 1e3 >>= withGrain 3 >>= withMultipliable\n \"tusinde\" -> double 1e3 >>= withGrain 3 >>= withMultipliable\n \"totusinde\" -> double (2 * 1e3) >>= withGrain 3 >>= withMultipliable\n \"million\" -> double 1e6 >>= withGrain 6 >>= withMultipliable\n \"millioner\" -> double 1e6 >>= withGrain 6 >>= withMultipliable\n _ -> Nothing\n _ -> Nothing\n }\n\nruleAPair :: Rule\nruleAPair = Rule\n { name = \"a pair\"\n , pattern =\n [ regex \"et par\"\n ]\n , prod = \\_ -> integer 2 >>= withGrain 1\n }\n\nruleNumeralsOg :: Rule\nruleNumeralsOg = Rule\n { name = \"numbers og\"\n , pattern =\n [ Predicate $ numberBetween 1 10\n , regex \"og\"\n , oneOf [70, 20, 60, 50, 40, 90, 30, 80]\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v1}:\n _:\n Token Numeral NumeralData{TNumeral.value = v2}:\n _) -> double $ v1 + v2\n _ -> Nothing\n }\n\nruleDozen :: Rule\nruleDozen = Rule\n { name = \"dozen\"\n , pattern =\n [ regex \"dusin\"\n ]\n , prod = \\_ -> integer 12 >>= withGrain 1 >>= withMultipliable\n }\n\nruleMultiply :: Rule\nruleMultiply = Rule\n { name = \"compose by multiplication\"\n , pattern =\n [ dimension Numeral\n , Predicate isMultipliable\n ]\n , prod = \\tokens -> case tokens of\n (token1:token2:_) -> multiply token1 token2\n _ -> Nothing\n }\n\nzeroNineteenMap :: HashMap Text Integer\nzeroNineteenMap = HashMap.fromList\n [ (\"ingen\", 0)\n , (\"nul\", 0)\n , (\"intet\", 0)\n , (\"en\", 1)\n , (\"et\", 1)\n , (\"\u00c3\u00a9n\", 1)\n , (\"\u00c3\u00a9t\", 1)\n , (\"to\", 2)\n , (\"tre\", 3)\n , (\"fire\", 4)\n , (\"fem\", 5)\n , (\"seks\", 6)\n , (\"syv\", 7)\n , (\"otte\", 8)\n , (\"ni\", 9)\n , (\"ti\", 10)\n , (\"elleve\", 11)\n , (\"tolv\", 12)\n , (\"tretten\", 13)\n , (\"fjorten\", 14)\n , (\"femten\", 15)\n , (\"seksten\", 16)\n , (\"sytten\", 17)\n , (\"atten\", 18)\n , (\"nitten\", 19)\n ]\n\nruleInteger :: Rule\nruleInteger = Rule\n { name = \"integer (0..19)\"\n , pattern =\n [ regex \"(intet|ingen|nul|en|et|\u00c3\u00a9n|\u00c3\u00a9t|to|tretten|tre|fire|femten|fem|seksten|seks|syv|otte|nitten|ni|ti|elleve|tolv|fjorten|sytten|atten)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) zeroNineteenMap >>= integer\n _ -> Nothing\n }\n\nruleInteger2 :: Rule\nruleInteger2 = Rule\n { name = \"integer (20..90)\"\n , pattern =\n [ regex \"(tyve|tredive|fyrre|halvtreds|tres|halvfjerds|firs|halvfems)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of\n \"tyve\" -> integer 20\n \"tredive\" -> integer 30\n \"fyrre\" -> integer 40\n \"halvtreds\" -> integer 50\n \"tres\" -> integer 60\n \"halvfjerds\" -> integer 70\n \"firs\" -> integer 80\n \"halvfems\" -> integer 90\n _ -> Nothing\n _ -> Nothing\n }\n\nruleNumeralDotNumeral :: Rule\nruleNumeralDotNumeral = Rule\n { name = \"number dot number\"\n , pattern =\n [ dimension Numeral\n , regex \"komma\"\n , Predicate $ not . hasGrain\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v1}:\n _:\n Token Numeral NumeralData{TNumeral.value = v2}:\n _) -> double $ v1 + decimalsToDouble v2\n _ -> Nothing\n }\n\nruleIntegerWithThousandsSeparator :: Rule\nruleIntegerWithThousandsSeparator = Rule\n { name = \"integer with thousands separator .\"\n , pattern =\n [ regex \"(\\\\d{1,3}(\\\\.\\\\d\\\\d\\\\d){1,5})\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n parseDouble (Text.replace \".\" Text.empty match) >>= double\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleAPair\n , ruleDecimalNumeral\n , ruleDecimalWithThousandsSeparator\n , ruleDozen\n , ruleFew\n , ruleInteger\n , ruleInteger2\n , ruleInteger3\n , ruleIntegerWithThousandsSeparator\n , ruleIntersect\n , ruleMultiply\n , ruleNumeralDotNumeral\n , ruleNumeralsOg\n , ruleNumeralsPrefixWithNegativeOrMinus\n , ruleNumeralsSuffixesKMG\n , rulePowersOfTen\n , ruleSingle\n , ruleTen\n ]\n", "num_lines": 316} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Numeral.DE.Corpus\n ( corpus\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Locale\nimport Duckling.Numeral.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale DE Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (NumeralValue 0)\n [ \"0\"\n , \"null\"\n , \"keiner\"\n , \"keinen\"\n ]\n , examples (NumeralValue 1)\n [ \"1\"\n , \"eins\"\n , \"Eine\"\n , \"einen\"\n ]\n , examples (NumeralValue 3)\n [ \"3\"\n , \"Drei\"\n ]\n , examples (NumeralValue 8)\n [ \"acht\"\n ]\n , examples (NumeralValue 18)\n [ \"achtzehn\"\n ]\n , examples (NumeralValue 30)\n [ \"30\"\n , \"drei\u00c3\u0178ig\"\n , \"dreissig\"\n ]\n , examples (NumeralValue 33)\n [ \"33\"\n , \"dreiunddrei\u00c3\u0178ig\"\n , \"dreiunddreissig\"\n , \"0033\"\n ]\n , examples (NumeralValue 14)\n [ \"14\"\n , \"vierzehn\"\n ]\n , examples (NumeralValue 15)\n [ \"15\"\n , \"f\u00c3\u00bcnfzehn\"\n ]\n , examples (NumeralValue 16)\n [ \"16\"\n , \"sechzehn\"\n ]\n , examples (NumeralValue 17)\n [ \"17\"\n , \"Siebzehn\"\n ]\n , examples (NumeralValue 18)\n [ \"18\"\n , \"achtzehn\"\n ]\n , examples (NumeralValue 200)\n [ \"200\"\n , \"zweihundert\"\n ]\n , examples (NumeralValue 102)\n [ \"102\"\n , \"Hundertzwei\"\n ]\n , examples (NumeralValue 1.1)\n [ \"1,1\"\n , \"1 komma 1\"\n , \"1,10\"\n , \"01,10\"\n ]\n , examples (NumeralValue 0.77)\n [ \"0,77\"\n , \",77\"\n ]\n , examples (NumeralValue 100000)\n [ \"100.000\"\n , \"100000\"\n , \"100K\"\n , \"100k\"\n , \"einhunderttausend\"\n , \"hunderttausend\"\n ]\n , examples (NumeralValue 3000000)\n [ \"3M\"\n , \"3000K\"\n , \"3000000\"\n , \"3.000.000\"\n , \"drei Millionen\"\n ]\n , examples (NumeralValue 1200000)\n [ \"1.200.000\"\n , \"1200000\"\n , \"1,2M\"\n , \"1200K\"\n , \",0012G\"\n ]\n , examples (NumeralValue (-1200000))\n [ \"- 1.200.000\"\n , \"-1200000\"\n , \"minus 1.200.000\"\n , \"negativ 1200000\"\n , \"-1,2M\"\n , \"-1200K\"\n , \"-,0012G\"\n ]\n , examples (NumeralValue 1852)\n [ \"eintausendachthundertzweiundf\u00c3\u00bcnfzig\"\n , \"tausendachthundertzweiundf\u00c3\u00bcnfzig\"\n , \"achtzehnhundertzweiundf\u00c3\u00bcnfzig\"]\n , examples (NumeralValue 5000)\n [ \"5 tausend\"\n , \"f\u00c3\u00bcnftausend\"\n ]\n , examples (NumeralValue 200000)\n [ \"zweihunderttausend\"\n ]\n , examples (NumeralValue 721012)\n [ \"siebenhunderteinundzwanzigtausendzw\u00c3\u00b6lf\"\n , \"siebenhunderteinundzwanzigtausendundzw\u00c3\u00b6lf\"\n ]\n , examples (NumeralValue 31256721)\n [ \"einunddreissig millionen zweihundertsechsundf\u00c3\u00bcnfzigtausendsiebenhunderteinundzwanzig\"\n , \"einunddrei\u00c3\u0178ig Millionen zweihundertsechsundf\u00c3\u00bcnfzigtausendundsiebenhunderteinundzwanzig\"\n ]\n , examples (NumeralValue 1416.15)\n [ \"1416,15\"\n , \"tausendvierhundertsechzehn Komma f\u00c3\u00bcnfzehn\"\n ]\n , examples (NumeralValue 1000000.0)\n [ \"1.000.000,00\",\n \"eine million\"\n ]\n , examples (NumeralValue 2771090092000000.0)\n [ \"zwei billiarden siebenhunderteinundsiebzig billionen neunzig milliarden zweiundneunzig millionen\"\n ]\n ]\n", "num_lines": 160} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n{-# LANGUAGE DeriveFunctor #-}\n\nmodule Duckling.Numeral.DE.NumParser (parseNumeral) where\n\nimport Control.Applicative\nimport Data.Char\nimport Data.Foldable\nimport Data.List\nimport Data.String\nimport Prelude\n\nnewtype Parser a = Parser {runParser :: String -> Maybe (a, String)}\n deriving (Functor)\n\nchar :: Char -> Parser Char\nchar c = Parser p\n where\n p [] = Nothing\n p (x : xs)\n | x == c = Just (x, xs)\n | otherwise = Nothing\n\ninstance Applicative Parser where\n pure a = Parser (\\s -> Just (a, s))\n (Parser fp) <*> xp = Parser $ \\s ->\n case fp s of\n Nothing -> Nothing\n Just (f, s') -> runParser (f <$> xp) s'\n\ninstance Alternative Parser where\n empty = Parser (const Nothing)\n Parser p1 <|> Parser p2 = Parser $ liftA2 (<|>) p1 p2\n\ntype NumParser = Parser Integer\n\n(.+.) :: NumParser -> NumParser -> NumParser\np .+. p' = (+) <$> p <*> p'\n\n(.*.) :: NumParser -> NumParser -> NumParser\np .*. p' = (*) <$> p <*> p'\n\ninfixl 6 .+.\n\ninfixl 7 .*.\n\nopt :: NumParser -> NumParser\nopt p = p <|> Parser p'\n where\n p' s = Just (0, s)\n\ndata NumItem = NumItem\n { base :: NumParser\n , plus10 :: NumParser\n , times10 :: [NumParser]\n }\n\ndefaultNumItem :: Integer -> String -> NumItem\ndefaultNumItem value form =\n NumItem\n { base = p\n , plus10 = p .+. ten\n , times10 = [p .*. ty]\n }\n where\n p = assign value form\n\ntype Assignment = Integer -> String -> NumParser\n\nassign :: Assignment\nassign value = foldr (\\c p -> (1 <$ char c) .*. p) (pure value)\n\nten :: NumParser\nten = assign 10 \"zehn\"\n\nty :: NumParser\nty = assign 10 \"zig\"\n\nhundred :: NumParser\nhundred = assign 100 \"hundert\"\n\nthousand :: NumParser\nthousand = assign 1000 \"tausend\"\n\nund :: NumParser\nund = assign 0 \"und\"\n\none :: NumItem\none =\n (defaultNumItem 1 \"ein\")\n { plus10 = assign 11 \"elf\"\n , times10 = [ten]\n }\n\ntwo :: NumItem\ntwo =\n (defaultNumItem 2 \"zwei\")\n { plus10 = assign 12 \"zw\u00c3\u00b6lf\"\n , times10 = [assign 20 \"zwanzig\"]\n }\n\nthree :: NumItem\nthree =\n (defaultNumItem 3 \"drei\")\n { times10 =\n [ assign 30 \"drei\u00c3\u0178ig\"\n , assign 30 \"dreissig\"\n ]\n }\n\nfour :: NumItem\nfour = defaultNumItem 4 \"vier\"\n\nfive :: NumItem\nfive = defaultNumItem 5 \"f\u00c3\u00bcnf\"\n\nsix :: NumItem\nsix =\n (defaultNumItem 6 \"sechs\")\n { plus10 = assign 16 \"sechzehn\"\n , times10 = [assign 60 \"sechzig\"]\n }\n\nseven :: NumItem\nseven =\n (defaultNumItem 7 \"sieben\")\n { plus10 = assign 17 \"siebzehn\"\n , times10 = [assign 70 \"siebzig\"]\n }\n\neight :: NumItem\neight = defaultNumItem 8 \"acht\"\n\nnine :: NumItem\nnine = defaultNumItem 9 \"neun\"\n\ndigitLexicon :: [NumItem]\ndigitLexicon = [one, two, three, four, five, six, seven, eight, nine]\n\nfrom1to9 :: NumParser\nfrom1to9 = foldr ((<|>) . base) empty digitLexicon\n\ntensFrom20 :: NumParser\ntensFrom20 = asum (concatMap times10 (tail digitLexicon))\n\nfrom1to99 :: NumParser\nfrom1to99 =\n opt (from1to9 .+. und) .+. tensFrom20\n <|> foldr ((<|>) . plus10) empty digitLexicon\n <|> ten\n <|> from1to9\n\nfrom1to999 :: NumParser\nfrom1to999 = opt (from1to9 .*. hundred .+. opt und) .+. opt from1to99\n\nfrom1to999999 :: NumParser\nfrom1to999999 = opt (from1to999 .*. thousand .+. opt und) .+. opt from1to999\n\nfrom1to999999' :: NumParser\nfrom1to999999' = Parser p\n where\n p s\n | isPrefixOf \"hundert\" s || isPrefixOf \"tausend\" s =\n runParser from1to999999 (\"ein\" ++ s)\n | otherwise =\n runParser from1to999999 s\n\nfromYear1100to1999 :: NumParser\nfromYear1100to1999 =\n asum ((\\n -> plus10 n .*. hundred) <$> digitLexicon)\n .+. opt (opt und .+. from1to99)\n\nallNumerals :: NumParser\nallNumerals =\n fromYear1100to1999\n <|> from1to999999'\n\nremoveInflection :: (Integer, String) -> Maybe Integer\nremoveInflection (n, suffix)\n | n `mod` 10 == 1 && suffix `elem` inflection = Just n\n where\n inflection = [\"s\", \"e\", \"em\", \"en\", \"er\", \"es\"]\nremoveInflection (n, \"\") = Just n\nremoveInflection _ = Nothing\n\nparseNumeral :: String -> Maybe Integer\nparseNumeral s = removeInflection =<< runParser allNumerals s\n", "num_lines": 192} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE NoRebindableSyntax #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Numeral.DE.Rules\n ( rules\n ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport Data.Maybe\nimport Data.Text (Text)\nimport Prelude\nimport Data.String\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers\nimport Duckling.Numeral.Types (NumeralData (..))\nimport Duckling.Regex.Types\nimport Duckling.Types\nimport qualified Duckling.Numeral.Types as TNumeral\nimport Duckling.Numeral.DE.NumParser\n\nruleNumeralsPrefixWithNegativeOrMinus :: Rule\nruleNumeralsPrefixWithNegativeOrMinus = Rule\n { name = \"numbers prefix with -, negative or minus\"\n , pattern =\n [ regex \"-|minus|negativ\"\n , Predicate isPositive\n ]\n , prod = \\tokens -> case tokens of\n (_:Token Numeral NumeralData{TNumeral.value = v}:_) ->\n double $ v * (- 1)\n _ -> Nothing\n }\n\nruleFew :: Rule\nruleFew = Rule\n { name = \"few\"\n , pattern =\n [ regex \"mehrere\"\n ]\n , prod = \\_ -> integer 3\n }\n\nruleDecimalWithThousandsSeparator :: Rule\nruleDecimalWithThousandsSeparator = Rule\n { name = \"decimal with thousands separator\"\n , pattern =\n [ regex \"(\\\\d+(\\\\.\\\\d\\\\d\\\\d)+\\\\,\\\\d+)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):\n _) -> let fmt = Text.replace \",\" \".\" $ Text.replace \".\" Text.empty match\n in parseDouble fmt >>= double\n _ -> Nothing\n }\n\nruleDecimalNumeral :: Rule\nruleDecimalNumeral = Rule\n { name = \"decimal number\"\n , pattern =\n [ regex \"(\\\\d*,\\\\d+)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n parseDecimal False match\n _ -> Nothing\n }\n\nruleNumeralsUnd :: Rule\nruleNumeralsUnd = Rule\n { name = \"numbers und\"\n , pattern =\n [ Predicate $ numberBetween 1 10\n , regex \"und\"\n , oneOf [20, 30 .. 90]\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v1}:\n _:\n Token Numeral NumeralData{TNumeral.value = v2}:\n _) -> double $ v1 + v2\n _ -> Nothing\n }\n\nruleMultiply :: Rule\nruleMultiply = Rule\n { name = \"compose by multiplication\"\n , pattern =\n [ dimension Numeral\n , Predicate isMultipliable\n ]\n , prod = \\tokens -> case tokens of\n (token1:token2:_) -> multiply token1 token2\n _ -> Nothing\n }\n\nruleIntersect :: Rule\nruleIntersect = Rule\n { name = \"intersect\"\n , pattern =\n [ Predicate hasGrain\n , Predicate $ and . sequence [not . isMultipliable, isPositive]\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = val1, TNumeral.grain = Just g}:\n Token Numeral NumeralData{TNumeral.value = val2}:\n _) | (10 ** fromIntegral g) > val2 -> double $ val1 + val2\n _ -> Nothing\n }\n\nruleNumeralsSuffixesKMG :: Rule\nruleNumeralsSuffixesKMG = Rule\n { name = \"numbers suffixes (K, M, G)\"\n , pattern =\n [ dimension Numeral\n , regex \"([kmg])(?=[\\\\W\\\\$\u00e2\u201a\u00ac]|$)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v}:\n Token RegexMatch (GroupMatch (match:_)):\n _) -> case Text.toLower match of\n \"k\" -> double $ v * 1e3\n \"m\" -> double $ v * 1e6\n \"g\" -> double $ v * 1e9\n _ -> Nothing\n _ -> Nothing\n }\n\nruleCouple :: Rule\nruleCouple = Rule\n { name = \"couple\"\n , pattern =\n [ regex \"(ein )?paar\"\n ]\n , prod = \\_ -> integer 2\n }\n\nruleDozen :: Rule\nruleDozen = Rule\n { name = \"dozen\"\n , pattern =\n [ regex \"dutzend\"\n ]\n , prod = \\_ -> integer 12 >>= withGrain 1 >>= withMultipliable\n }\n\nrulePowersOfTen :: Rule\nrulePowersOfTen = Rule\n { name = \"powers of tens\"\n , pattern =\n [ regex \"(hunderte?|tausende?|million(en)?|milliarde(n)?|billion(en)?|billiarde(n)?)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of\n \"hundert\" -> double 1e2 >>= withGrain 2 >>= withMultipliable\n \"hunderte\" -> double 1e2 >>= withGrain 2 >>= withMultipliable\n \"tausend\" -> double 1e3 >>= withGrain 3 >>= withMultipliable\n \"tausende\" -> double 1e3 >>= withGrain 3 >>= withMultipliable\n \"million\" -> double 1e6 >>= withGrain 6 >>= withMultipliable\n \"millionen\" -> double 1e6 >>= withGrain 6 >>= withMultipliable\n \"milliarde\" -> double 1e9 >>= withGrain 9 >>= withMultipliable\n \"milliarden\" -> double 1e9 >>= withGrain 9 >>= withMultipliable\n \"billion\" -> double 1e12 >>= withGrain 12 >>= withMultipliable\n \"billionen\" -> double 1e12 >>= withGrain 12 >>= withMultipliable\n \"billiarde\" -> double 1e15 >>= withGrain 15 >>= withMultipliable\n \"billiarden\" -> double 1e15 >>= withGrain 15 >>= withMultipliable\n _ -> Nothing\n _ -> Nothing\n }\n\nruleZero :: Rule\nruleZero = Rule\n { name = \"integer 0\"\n , pattern =\n [ regex \"(keine(m|n|r|s)?|keins?|null|nichts)\"\n ]\n , prod = \\_ -> integer 0\n }\n\nruleNumeralDotNumeral :: Rule\nruleNumeralDotNumeral = Rule\n { name = \"number dot number\"\n , pattern =\n [ dimension Numeral\n , regex \"komma\"\n , Predicate $ not . hasGrain\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v1}:\n _:\n Token Numeral NumeralData{TNumeral.value = v2}:\n _) -> double $ v1 + decimalsToDouble v2\n _ -> Nothing\n }\n\nruleIntegerWithThousandsSeparator :: Rule\nruleIntegerWithThousandsSeparator = Rule\n { name = \"integer with thousands separator .\"\n , pattern =\n [ regex \"(\\\\d{1,3}(\\\\.\\\\d\\\\d\\\\d){1,5})\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n parseDouble (Text.replace \".\" Text.empty match) >>= double\n _ -> Nothing\n }\n\nruleAllNumeralWords :: Rule\nruleAllNumeralWords = Rule\n { name = \"simple and complex numerals written as one word\"\n , pattern = [regex \"(ein|zwei|drei|vier|f\u00c3\u00bcnf|sech|sieb|acht|neun|zehn|elf|zw\u00c3\u00b6lf|hundert|tausend)?([^\\\\s]+)?(eine[m|n|r|s]?|eins?|zwei|drei|vier|f\u00c3\u00bcnf|sechs|sieben|acht|neun|zehn|elf|zw\u00c3\u00b6lf|[s|\u00c3\u0178|z]ig|hundert|tausend)\"]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch matches) : _) ->\n (parseNumeral $ concat $ Text.unpack . Text.toLower <$> matches)\n >>= integer\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleCouple\n , ruleDecimalNumeral\n , ruleDecimalWithThousandsSeparator\n , ruleDozen\n , ruleFew\n , ruleIntegerWithThousandsSeparator\n , ruleIntersect\n , ruleMultiply\n , ruleNumeralDotNumeral\n , ruleNumeralsPrefixWithNegativeOrMinus\n , ruleNumeralsSuffixesKMG\n , ruleNumeralsUnd\n , rulePowersOfTen\n , ruleZero\n , ruleAllNumeralWords\n ]\n", "num_lines": 247} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Numeral.EN.Corpus\n ( corpus ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Numeral.Types\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (NumeralValue 0)\n [ \"0\"\n , \"naught\"\n , \"nought\"\n , \"zero\"\n , \"nil\"\n ]\n , examples (NumeralValue 1)\n [ \"1\"\n , \"one\"\n , \"single\"\n ]\n , examples (NumeralValue 2)\n [ \"2\"\n , \"two\"\n , \"a pair\"\n , \"a couple\"\n , \"a couple of\"\n ]\n , examples (NumeralValue 3)\n [ \"3\"\n , \"three\"\n , \"a few\"\n , \"few\"\n ]\n , examples (NumeralValue 10)\n [ \"10\"\n , \"ten\"\n ]\n , examples (NumeralValue 12)\n [ \"12\"\n , \"twelve\"\n , \"a dozen\"\n , \"a dozen of\"\n ]\n , examples (NumeralValue 14)\n [ \"14\"\n , \"fourteen\"\n ]\n , examples (NumeralValue 16)\n [ \"16\"\n , \"sixteen\"\n ]\n , examples (NumeralValue 17)\n [ \"17\"\n , \"seventeen\"\n ]\n , examples (NumeralValue 18)\n [ \"18\"\n , \"eighteen\"\n ]\n , examples (NumeralValue 33)\n [ \"33\"\n , \"thirty three\"\n , \"0033\"\n ]\n , examples (NumeralValue 24)\n [ \"24\"\n , \"2 dozens\"\n , \"two dozen\"\n , \"Two dozen\"\n ]\n , examples (NumeralValue 1.1)\n [ \"1.1\"\n , \"1.10\"\n , \"01.10\"\n , \"1 point 1\"\n ]\n , examples (NumeralValue 0.77)\n [ \".77\"\n , \"0.77\"\n , \"point 77\"\n ]\n , examples (NumeralValue 100000)\n [ \"100,000\"\n , \"100,000.0\"\n , \"100000\"\n , \"100K\"\n , \"100k\"\n , \"one hundred thousand\"\n ]\n , examples (NumeralValue 0.2)\n [ \"1/5\"\n , \"2/10\"\n , \"3/15\"\n , \"20/100\"\n ]\n , examples (NumeralValue 3e6)\n [ \"3M\"\n , \"3000K\"\n , \"3000000\"\n , \"3,000,000\"\n , \"3 million\"\n , \"30 lakh\"\n , \"30 lkh\"\n , \"30 l\"\n ]\n , examples (NumeralValue 1.2e6)\n [ \"1,200,000\"\n , \"1200000\"\n , \"1.2M\"\n , \"1200k\"\n , \".0012G\"\n , \"12 lakhs\"\n , \"12 lkhs\"\n ]\n , examples (NumeralValue 5000)\n [ \"5 thousand\"\n , \"five thousand\"\n ]\n , examples (NumeralValue (-504))\n [ \"-504\"\n , \"negative five hundred and four\"\n ]\n , examples (NumeralValue (-1.2e6))\n [ \"- 1,200,000\"\n , \"-1200000\"\n , \"minus 1,200,000\"\n , \"negative 1200000\"\n , \"-1.2M\"\n , \"-1200K\"\n , \"-.0012G\"\n ]\n , examples (NumeralValue (-3200000))\n [ \"-3,200,000\"\n , \"-3200000\"\n , \"minus three million two hundred thousand\"\n ]\n , examples (NumeralValue 122)\n [ \"one twenty two\"\n , \"ONE TwentY tWO\"\n ]\n , examples (NumeralValue 2e5)\n [ \"two Hundred thousand\"\n ]\n , examples (NumeralValue 21011)\n [ \"twenty-one thousand Eleven\"\n ]\n , examples (NumeralValue 721012)\n [ \"seven hundred twenty-one thousand twelve\"\n , \"seven hundred twenty-one thousand and twelve\"\n ]\n , examples (NumeralValue 31256721)\n [ \"thirty-one million two hundred fifty-six thousand seven hundred twenty-one\"\n , \"three crore twelve lakh fifty-six thousand seven hundred twenty-one\"\n , \"three cr twelve lac fifty-six thousand seven hundred twenty-one\"\n ]\n , examples (NumeralValue 2400)\n [ \"two hundred dozens\"\n , \"200 dozens\"\n ]\n , examples (NumeralValue 2200000)\n [ \"two point two million\"\n ]\n , examples (NumeralValue 3000000000)\n [ \"three billions\"\n , \"three thousand millions\"\n , \"three hundred crores\"\n , \"three hundred Cr\"\n , \"three hundred koti\"\n , \"three hundred krores\"\n , \"three hundred Kr\"\n ]\n , examples (NumeralValue 45)\n [ \"forty-five (45)\"\n , \"45 (forty five)\"\n ]\n ]\n", "num_lines": 192} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE NoRebindableSyntax #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Numeral.EN.Rules\n ( rules\n ) where\n\nimport Control.Applicative ((<|>))\nimport Data.HashMap.Strict (HashMap)\nimport Data.Maybe\nimport Data.Text (Text)\nimport Prelude\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers\nimport Duckling.Numeral.Types (NumeralData (..), isInteger)\nimport Duckling.Regex.Types\nimport Duckling.Types\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleDozen :: Rule\nruleDozen = Rule\n { name = \"a dozen of\"\n , pattern =\n [ regex \"(a )?dozens?( of)?\"\n ]\n , prod = \\_ -> integer 12 >>= withMultipliable >>= notOkForAnyTime\n }\n\nzeroNineteenMap :: HashMap Text Integer\nzeroNineteenMap = HashMap.fromList\n [ ( \"naught\" , 0 )\n , ( \"nil\" , 0 )\n , ( \"nought\" , 0 )\n , ( \"none\" , 0 )\n , ( \"zero\" , 0 )\n , ( \"zilch\" , 0 )\n , ( \"one\" , 1 )\n , ( \"two\" , 2 )\n , ( \"three\" , 3 )\n , ( \"four\" , 4 )\n , ( \"five\" , 5 )\n , ( \"six\" , 6 )\n , ( \"seven\" , 7 )\n , ( \"eight\" , 8 )\n , ( \"nine\" , 9 )\n , ( \"ten\" , 10 )\n , ( \"eleven\" , 11 )\n , ( \"twelve\" , 12 )\n , ( \"thirteen\" , 13 )\n , ( \"fourteen\" , 14 )\n , ( \"fifteen\" , 15 )\n , ( \"sixteen\" , 16 )\n , ( \"seventeen\", 17 )\n , ( \"eighteen\" , 18 )\n , ( \"nineteen\" , 19 )\n ]\n\ninformalMap :: HashMap Text Integer\ninformalMap = HashMap.fromList\n [ ( \"single\" , 1 )\n , ( \"a couple\" , 2 )\n , ( \"a couple of\", 2 )\n , ( \"couple\" , 2 )\n , ( \"couples\" , 2 )\n , ( \"couple of\" , 2 )\n , ( \"couples of\" , 2 )\n , ( \"a pair\" , 2 )\n , ( \"a pair of\" , 2 )\n , ( \"pair\" , 2 )\n , ( \"pairs\" , 2 )\n , ( \"pair of\" , 2 )\n , ( \"pairs of\" , 2 )\n , ( \"a few\" , 3 )\n , ( \"few\" , 3 )\n ]\n\nruleToNineteen :: Rule\nruleToNineteen = Rule\n { name = \"integer (0..19)\"\n -- e.g. fourteen must be before four, otherwise four will always shadow fourteen\n , pattern =\n [ regex \"(none|zilch|naught|nought|nil|zero|one|single|two|(a )?(pair|couple)s?( of)?|three|(a )?few|fourteen|four|fifteen|five|sixteen|six|seventeen|seven|eighteen|eight|nineteen|nine|ten|eleven|twelve|thirteen)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n let x = Text.toLower match in\n (HashMap.lookup x zeroNineteenMap >>= integer) <|>\n (HashMap.lookup x informalMap >>= integer >>= notOkForAnyTime)\n _ -> Nothing\n }\n\ntensMap :: HashMap Text Integer\ntensMap = HashMap.fromList\n [ ( \"twenty\" , 20 )\n , ( \"thirty\" , 30 )\n , ( \"forty\" , 40 )\n , ( \"fourty\" , 40 )\n , ( \"fifty\" , 50 )\n , ( \"sixty\" , 60 )\n , ( \"seventy\" , 70 )\n , ( \"eighty\" , 80 )\n , ( \"ninety\" , 90 )\n ]\n\nruleTens :: Rule\nruleTens = Rule\n { name = \"integer (20..90)\"\n , pattern =\n [ regex \"(twenty|thirty|fou?rty|fifty|sixty|seventy|eighty|ninety)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) tensMap >>= integer\n _ -> Nothing\n }\n\npowersOfTensMap :: HashMap Text Int\npowersOfTensMap = HashMap.fromList\n [ (\"hundred\", 2)\n , (\"thousand\", 3)\n , (\"lakh\", 5)\n , (\"lkh\", 5)\n , (\"l\", 5)\n , (\"lac\", 5)\n , (\"million\", 6)\n , (\"cr\", 7)\n , (\"crore\", 7)\n , (\"krore\", 7)\n , (\"kr\", 7)\n , (\"koti\", 7)\n , (\"billion\", 9)\n , (\"trillion\", 12)\n ]\n\nrulePowersOfTen :: Rule\nrulePowersOfTen = Rule\n { name = \"powers of tens\"\n , pattern = [regex \"(hundred|thousand|l(ac|(a?kh)?)|million|((k|c)r(ore)?|koti)|billion)s?\"]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match : _)) : _) -> do\n grain <- HashMap.lookup (Text.toLower match) powersOfTensMap\n double (10 ^ grain) >>= withGrain grain >>= withMultipliable\n _ -> Nothing\n }\n\nruleCompositeTens :: Rule\nruleCompositeTens = Rule\n { name = \"integer 21..99\"\n , pattern =\n [ oneOf [20,30..90]\n , regex \"[\\\\s\\\\-]+\"\n , Predicate $ numberBetween 1 10\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = tens}:\n _:\n Token Numeral NumeralData{TNumeral.value = units}:\n _) -> double $ tens + units\n _ -> Nothing\n }\n\nruleSkipHundreds1 :: Rule\nruleSkipHundreds1 = Rule\n { name = \"one eleven\"\n , pattern =\n [ regex \"(one|two|three|four|five|six|seven|eight|nine)\"\n , regex \"(ten|eleven|twelve|thirteen|fourteen|fifteen|sixteen|seventeen|eighteen|nineteen|twenty|thirty|fou?rty|fifty|sixty|seventy|eighty|ninety)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (m1:_)):\n Token RegexMatch (GroupMatch (m2:_)):\n _) -> do\n let x1 = Text.toLower m1\n let x2 = Text.toLower m2\n hundreds <- HashMap.lookup x1 zeroNineteenMap\n rest <- HashMap.lookup x2 zeroNineteenMap <|> HashMap.lookup x2 tensMap\n integer (hundreds * 100 + rest)\n _ -> Nothing\n }\n\nruleSkipHundreds2 :: Rule\nruleSkipHundreds2 = Rule\n { name = \"one twenty two\"\n , pattern =\n [ regex \"(one|two|three|four|five|six|seven|eight|nine)\"\n , regex \"(twenty|thirty|fou?rty|fifty|sixty|seventy|eighty|ninety)\"\n , regex \"(one|two|three|four|five|six|seven|eight|nine)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (m1:_)):\n Token RegexMatch (GroupMatch (m2:_)):\n Token RegexMatch (GroupMatch (m3:_)):\n _) -> do\n let x1 = Text.toLower m1\n let x2 = Text.toLower m2\n let x3 = Text.toLower m3\n hundreds <- HashMap.lookup x1 zeroNineteenMap\n tens <- HashMap.lookup x2 tensMap\n rest <- HashMap.lookup x3 zeroNineteenMap\n integer (hundreds * 100 + tens + rest)\n _ -> Nothing\n }\n\nruleDotSpelledOut :: Rule\nruleDotSpelledOut = Rule\n { name = \"one point 2\"\n , pattern =\n [ dimension Numeral\n , regex \"point|dot\"\n , Predicate $ not . hasGrain\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral nd1:_:Token Numeral nd2:_) ->\n double $ TNumeral.value nd1 + decimalsToDouble (TNumeral.value nd2)\n _ -> Nothing\n }\n\nruleLeadingDotSpelledOut :: Rule\nruleLeadingDotSpelledOut = Rule\n { name = \"point 77\"\n , pattern =\n [ regex \"point|dot\"\n , Predicate $ not . hasGrain\n ]\n , prod = \\tokens -> case tokens of\n (_:Token Numeral nd:_) -> double . decimalsToDouble $ TNumeral.value nd\n _ -> Nothing\n }\n\nruleDecimals :: Rule\nruleDecimals = Rule\n { name = \"decimal number\"\n , pattern =\n [ regex \"(\\\\d*\\\\.\\\\d+)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> parseDecimal True match\n _ -> Nothing\n }\n\nruleCommas :: Rule\nruleCommas = Rule\n { name = \"comma-separated numbers\"\n , pattern =\n [ regex \"(\\\\d+(,\\\\d\\\\d\\\\d)+(\\\\.\\\\d+)?)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n parseDouble (Text.replace \",\" Text.empty match) >>= double\n _ -> Nothing\n }\n\nruleSuffixes :: Rule\nruleSuffixes = Rule\n { name = \"suffixes (K,M,G))\"\n , pattern =\n [ dimension Numeral\n , regex \"(k|m|g)(?=[\\\\W$\u00e2\u201a\u00ac\u00c2\u00a2\u00c2\u00a3]|$)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral nd : Token RegexMatch (GroupMatch (match : _)):_) -> do\n x <- case Text.toLower match of\n \"k\" -> Just 1e3\n \"m\" -> Just 1e6\n \"g\" -> Just 1e9\n _ -> Nothing\n double $ TNumeral.value nd * x\n _ -> Nothing\n }\n\nruleNegative :: Rule\nruleNegative = Rule\n { name = \"negative numbers\"\n , pattern =\n [ regex \"(-|minus|negative)(?!\\\\s*-)\"\n , Predicate isPositive\n ]\n , prod = \\tokens -> case tokens of\n (_:Token Numeral nd:_) -> double (TNumeral.value nd * (-1))\n _ -> Nothing\n }\n\nruleSum :: Rule\nruleSum = Rule\n { name = \"intersect 2 numbers\"\n , pattern =\n [ Predicate $ and . sequence [hasGrain, isPositive]\n , Predicate $ and . sequence [not . isMultipliable, isPositive]\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = val1, TNumeral.grain = Just g}:\n Token Numeral NumeralData{TNumeral.value = val2}:\n _) | (10 ** fromIntegral g) > val2 -> double $ val1 + val2\n _ -> Nothing\n }\n\nruleSumAnd :: Rule\nruleSumAnd = Rule\n { name = \"intersect 2 numbers (with and)\"\n , pattern =\n [ Predicate $ and . sequence [hasGrain, isPositive]\n , regex \"and\"\n , Predicate $ and . sequence [not . isMultipliable, isPositive]\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = val1, TNumeral.grain = Just g}:\n _:\n Token Numeral NumeralData{TNumeral.value = val2}:\n _) | (10 ** fromIntegral g) > val2 -> double $ val1 + val2\n _ -> Nothing\n }\n\nruleMultiply :: Rule\nruleMultiply = Rule\n { name = \"compose by multiplication\"\n , pattern =\n [ Predicate isPositive\n , Predicate isMultipliable\n ]\n , prod = \\tokens -> case tokens of\n (token1:token2:_) -> multiply token1 token2\n _ -> Nothing\n }\n\nruleLegalParentheses :: Rule\nruleLegalParentheses = Rule\n { name = \" '('')'\"\n , pattern =\n [ numberWith TNumeral.value $ and . sequence [isInteger, (>0)]\n , regex \"\\\\(\"\n , numberWith TNumeral.value $ and . sequence [isInteger, (>0)]\n , regex \"\\\\)\"\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = n1}:\n _:\n Token Numeral NumeralData{TNumeral.value = n2}:\n _:\n _) | n1 == n2 -> double n1\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleToNineteen\n , ruleTens\n , rulePowersOfTen\n , ruleCompositeTens\n , ruleSkipHundreds1\n , ruleSkipHundreds2\n , ruleDotSpelledOut\n , ruleLeadingDotSpelledOut\n , ruleDecimals\n , ruleCommas\n , ruleSuffixes\n , ruleNegative\n , ruleSum\n , ruleSumAnd\n , ruleMultiply\n , ruleDozen\n , ruleLegalParentheses\n ]\n", "num_lines": 375} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n{-# LANGUAGE NumericUnderscores #-}\nmodule Duckling.Numeral.ES.Corpus (corpus) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Locale\nimport Duckling.Numeral.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus =\n (testContext { locale = makeLocale ES Nothing }, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples =\n concat\n [ examples (NumeralValue 1) [\"1\", \"uno\", \"una\"]\n , examples (NumeralValue (-1)) [\"negativo 1\", \"menos 1\", \"negativo uno\"]\n , examples (NumeralValue 11) [\"once\"]\n , examples\n (NumeralValue 16)\n [\"diecis\u00c3\u00a9is\", \"dieciseis\", \"Diesiseis\", \"diez y seis\"]\n , examples (NumeralValue 21) [\"veintiuno\", \"veinte y uno\"]\n , examples (NumeralValue 22) [\"veintid\u00c3\u00b3s\"]\n , examples (NumeralValue 23) [\"veintitr\u00c3\u00a9s\", \"veinte y tres\"]\n , examples (NumeralValue 70) [\"setenta\"]\n , examples (NumeralValue 78) [\"Setenta y ocho\"]\n , examples (NumeralValue 80) [\"ochenta\"]\n , examples (NumeralValue 33) [\"33\", \"treinta y tres\", \"treinta y 3\"]\n , examples (NumeralValue 100_000) [\"100000\", \"100K\", \"100k\"]\n , examples (NumeralValue 300) [\"trescientos\"]\n , examples (NumeralValue 243) [\"243\"]\n , examples (NumeralValue 3_000_000) [\"3M\", \"3000K\", \"3000000\"]\n , examples (NumeralValue 1_200_000) [\"1200000\", \"1200K\"]\n , examples (NumeralValue (-1_200_000)) [\"-1200000\", \"-1200K\"]\n , examples (NumeralValue 1.5) [\"1 punto cinco\", \"una punto cinco\", \"1 con cinco\", \"1 con 5\", \"uno coma 5\"]\n , examples (NumeralValue 0.5) [\"punto cinco\", \"coma 5\"]\n , examples (NumeralValue 1) [\"cero uno\", \"zero uno\"]\n , examples (NumeralValue 2) [\"cero dos\", \"zero dos\"]\n , examples (NumeralValue 3)\n [\n \"cero tres\",\n \"cero tr\u00c3\u00a9s\",\n \"zero tres\",\n \"zero tr\u00c3\u00a9s\"\n ]\n , examples (NumeralValue 4) [\"cero cuatro\", \"zero cuatro\"]\n , examples (NumeralValue 5) [\"cero cinco\", \"zero cinco\"]\n , examples (NumeralValue 6)\n [\n \"cero seis\",\n \"cero s\u00c3\u00a9is\",\n \"zero seis\",\n \"zero s\u00c3\u00a9is\"\n ]\n , examples (NumeralValue 7) [\"cero siete\", \"zero siete\"]\n , examples (NumeralValue 8) [\"cero ocho\", \"zero ocho\"]\n , examples (NumeralValue 9) [\"cero nueve\", \"zero nueve\"]\n , examples (NumeralValue 203) [\"dos cientos tres\", \"doscientos tres\"]\n , examples (NumeralValue 203_000) [\"doscientos tres mil\", \"203 mil\"]\n , examples (NumeralValue 4_000_000) [\"cuatro millones\", \"4 millones\"]\n , examples (NumeralValue 4_002_003) [\"cuatro millones dos mil tres\", \"4 millones 2 mil 3\"]\n ]\n", "num_lines": 74} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n{-# LANGUAGE LambdaCase #-}\n\nmodule Duckling.Numeral.ES.Rules (rules) where\n\nimport qualified Data.HashMap.Strict as HashMap\nimport Data.Maybe\nimport Data.String\nimport qualified Data.Text as Text\nimport Prelude\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers\nimport Duckling.Numeral.Types (NumeralData(..))\nimport qualified Duckling.Numeral.Types as TNumeral\nimport Duckling.Regex.Types\nimport Duckling.Types\n\nzeroToFifteenMap :: HashMap.HashMap Text.Text Integer\nzeroToFifteenMap =\n HashMap.fromList\n [ (\"zero\", 0)\n , (\"cero\", 0)\n , (\"un\", 1)\n , (\"una\", 1)\n , (\"uno\", 1)\n , (\"dos\", 2)\n , (\"tr\u00c3\u00a9s\", 3)\n , (\"tres\", 3)\n , (\"cuatro\", 4)\n , (\"cinco\", 5)\n , (\"seis\", 6)\n , (\"s\u00c3\u00a9is\", 6)\n , (\"siete\", 7)\n , (\"ocho\", 8)\n , (\"nueve\", 9)\n , (\"diez\", 10)\n , (\"dies\", 10)\n , (\"once\", 11)\n , (\"doce\", 12)\n , (\"trece\", 13)\n , (\"catorce\", 14)\n , (\"quince\", 15)\n ]\n\nruleNumeralZeroToFifteen :: Rule\nruleNumeralZeroToFifteen = Rule\n { name = \"number (0..15)\"\n , pattern =\n [ regex\n \"((c|z)ero|un(o|a)?|dos|tr(\u00c3\u00a9|e)s|cuatro|cinco|s(e|\u00c3\u00a9)is|siete|ocho|nueve|die(z|s)|once|doce|trece|catorce|quince)\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match : _)) : _) ->\n HashMap.lookup (Text.toLower match) zeroToFifteenMap >>= integer\n _ -> Nothing\n }\n\nruleBelowTenWithTwoDigits :: Rule\nruleBelowTenWithTwoDigits = Rule\n {\n name = \"integer (0-9) with two digits\"\n , pattern =\n [ regex \"((c|z)ero)|0\"\n , Predicate $ numberBetween 1 10\n ]\n , prod = \\case\n (\n _:\n Token Numeral NumeralData { TNumeral.value = v }:\n _\n ) -> double v\n _ -> Nothing\n }\n\nsixteenToTwentyNineMap :: HashMap.HashMap Text.Text Integer\nsixteenToTwentyNineMap =\n HashMap.fromList\n [ (\"dieciseis\", 16)\n , (\"diesis\u00c3\u00a9is\", 16)\n , (\"diesiseis\", 16)\n , (\"diecis\u00c3\u00a9is\", 16)\n , (\"diecisiete\", 17)\n , (\"dieciocho\", 18)\n , (\"diecinueve\", 19)\n , (\"veintiuno\", 21)\n , (\"veintiuna\", 21)\n , (\"veintidos\", 22)\n , (\"veintid\u00c3\u00b3s\", 22)\n , (\"veintitr\u00c3\u00a9s\", 23)\n , (\"veintitres\", 23)\n , (\"veinticuatro\", 24)\n , (\"veinticinco\", 25)\n , (\"veintis\u00c3\u00a9is\", 26)\n , (\"veintiseis\", 26)\n , (\"veintisiete\", 27)\n , (\"veintiocho\", 28)\n , (\"veintinueve\", 29)\n ]\n\n\nruleNumeralSixteenToTwentyNine :: Rule\nruleNumeralSixteenToTwentyNine = Rule\n { name = \"number (16..19 21..29)\"\n , pattern =\n [ regex\n \"(die(c|s)is(\u00c3\u00a9|e)is|diecisiete|dieciocho|diecinueve|veintiun(o|a)|veintid(o|\u00c3\u00b3)s|veintitr(\u00c3\u00a9|e)s|veinticuatro|veinticinco|veintis(\u00c3\u00a9|e)is|veintisiete|veintiocho|veintinueve|treinta)\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match : _)) : _) ->\n HashMap.lookup (Text.toLower match) sixteenToTwentyNineMap >>= integer\n _ -> Nothing\n }\n\nruleNumeralSixteenToNineteenWithDiez :: Rule\nruleNumeralSixteenToNineteenWithDiez = Rule\n { name = \"number (16..19, two words)\"\n , pattern =\n [ numberWith TNumeral.value (== 10)\n , regex \"y\"\n , Predicate $ numberBetween 6 10\n ]\n , prod = \\case\n (_ : _ : Token Numeral NumeralData { TNumeral.value = v } : _) ->\n double $ 10 + v\n _ -> Nothing\n }\n\nbyTensMap :: HashMap.HashMap Text.Text Integer\nbyTensMap =\n HashMap.fromList\n [ (\"veinte\", 20)\n , (\"treinta\", 30)\n , (\"cuarenta\", 40)\n , (\"cincuenta\", 50)\n , (\"sesenta\", 60)\n , (\"setenta\", 70)\n , (\"ochenta\", 80)\n , (\"noventa\", 90)\n ]\n\n\nruleNumeralTwentyToNinetyTens :: Rule\nruleNumeralTwentyToNinetyTens = Rule\n { name = \"number (20..90)\"\n , pattern =\n [ regex\n \"(veinte|treinta|cuarenta|cincuenta|sesenta|setenta|ochenta|noventa)\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match : _)) : _) ->\n HashMap.lookup (Text.toLower match) byTensMap >>= integer\n _ -> Nothing\n }\n\nruleNumeralTwentyOneToNinetyNine :: Rule\nruleNumeralTwentyOneToNinetyNine = Rule\n { name = \"number (21..29 31..39 41..49 51..59 61..69 71..79 81..89 91..99)\"\n , pattern =\n [ oneOf [20, 30 .. 90]\n , regex \"y\"\n , Predicate $ numberBetween 1 10\n ]\n , prod = \\case\n (Token Numeral NumeralData { TNumeral.value = v1 } : _ : Token Numeral NumeralData { TNumeral.value = v2 } : _) ->\n double $ v1 + v2\n _ -> Nothing\n }\n\nbigNumbersMap :: HashMap.HashMap Text.Text Integer\nbigNumbersMap =\n HashMap.fromList\n [ (\"cien\", 100)\n , (\"cientos\", 100)\n , (\"ciento\", 100)\n , (\"doscientos\", 200)\n , (\"trescientos\", 300)\n , (\"cuatrocientos\", 400)\n , (\"quinientos\", 500)\n , (\"seiscientos\", 600)\n , (\"setecientos\", 700)\n , (\"ochocientos\", 800)\n , (\"novecientos\", 900)\n , (\"mil\", 1000)\n , (\"millon\", 1000000)\n , (\"mill\u00c3\u00b3n\", 1000000)\n , (\"un millon\", 1000000)\n , (\"un mill\u00c3\u00b3n\", 1000000)\n , (\"millones\", 1000000)\n -- Note: billion and larger is ambiguous becaouse of long vs short scale\n ]\n\nruleBigNumeral :: Rule\nruleBigNumeral = Rule\n { name = \"big number 100 to 1K\"\n , pattern =\n [ regex\n \"(cien(to|tos)?|doscientos|trescientos|cuatrocientos|quinientos|seiscientos|setecientos|ochocientos|novecientos|(un )?mill(o|\u00c3\u00b3)n)\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match : _)) : _) ->\n HashMap.lookup (Text.toLower match) bigNumbersMap >>= integer\n _ -> Nothing\n }\n\nruleBigNumeralMultipliable :: Rule\nruleBigNumeralMultipliable = Rule\n { name = \"1K or 1M in multipliable form\"\n , pattern =\n [ regex\n \"(mil(lones)?)\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match : _)) : _) ->\n HashMap.lookup (Text.toLower match) bigNumbersMap >>= integer >>= withMultipliable\n _ -> Nothing\n }\n\nruleTwoPartHundreds :: Rule\nruleTwoPartHundreds = Rule\n { name = \"2..9 cientos\"\n , pattern =\n [ Predicate $ numberBetween 2 10\n , regex \"cientos\"\n ]\n , prod = \\case\n (Token Numeral NumeralData { TNumeral.value = v1 } : _ : _) ->\n double $ 100 * v1\n _ -> Nothing\n }\n\nruleNumeralHundredsAndSmaller :: Rule\nruleNumeralHundredsAndSmaller = Rule\n { name = \" 0..99\"\n , pattern =\n [ numberWith TNumeral.value (TNumeral.isMultiple 100)\n , Predicate $ numberBetween 0 100\n ]\n , prod = \\case\n (Token Numeral NumeralData { TNumeral.value = v1 } : Token Numeral NumeralData { TNumeral.value = v2 } : _)\n | v1 > 0 && v1 < 1000 -> double $ v1 + v2\n _ -> Nothing\n }\n\nruleNumeralMultiply :: Rule\nruleNumeralMultiply = Rule\n { name = \"2..999 \"\n , pattern =\n [ Predicate $ numberBetween 2 1000\n , Predicate isMultipliable\n ]\n , prod = \\case\n (Token Numeral NumeralData { TNumeral.value = v1 } : Token Numeral NumeralData { TNumeral.value = v2 } : _) ->\n double $ v1 * v2\n _ -> Nothing\n }\n\nruleNumeralThousandsAnd :: Rule\nruleNumeralThousandsAnd = Rule\n { name = \" 0..999\"\n , pattern =\n [ numberWith TNumeral.value (TNumeral.isMultiple 1000)\n , Predicate $ numberBetween 0 999\n ]\n , prod = \\case\n (Token Numeral NumeralData { TNumeral.value = v1 } : Token Numeral NumeralData { TNumeral.value = v2 } : _)\n | 0 < v1 && v1 < 1000000 -> double $ v1 + v2\n _ -> Nothing\n }\n\nruleNumeralMillionsAnd :: Rule\nruleNumeralMillionsAnd = Rule\n { name = \" 0..999999\"\n , pattern =\n [ numberWith TNumeral.value (TNumeral.isMultiple 1000000)\n , Predicate $ numberBetween 0 999999\n ]\n , prod = \\case\n (Token Numeral NumeralData { TNumeral.value = v1 } : Token Numeral NumeralData { TNumeral.value = v2 } : _)\n | 0 < v1 -> double $ v1 + v2\n _ -> Nothing\n }\n\nruleNumeralDotNumeral :: Rule\nruleNumeralDotNumeral = Rule\n { name = \"number dot number\"\n , pattern = [dimension Numeral, regex \"(co(n|ma)|punto)\", Predicate $ not . hasGrain]\n , prod = \\case\n (Token Numeral NumeralData { TNumeral.value = v1 } : _ : Token Numeral NumeralData { TNumeral.value = v2 } : _) ->\n double $ v1 + decimalsToDouble v2\n _ -> Nothing\n }\n\nruleLeadingDotNumeral :: Rule\nruleLeadingDotNumeral = Rule\n { name = \"dot number\"\n , pattern = [regex \"coma|punto\", Predicate $ not . hasGrain]\n , prod = \\case\n (_:Token Numeral NumeralData{TNumeral.value = v}:_) ->\n double $ decimalsToDouble v\n _ -> Nothing\n }\n\nruleNumeralsSuffixesKMG :: Rule\nruleNumeralsSuffixesKMG = Rule\n { name = \"numbers suffixes (K, M, G)\"\n , pattern = [dimension Numeral, regex \"([kmg])(?=[\\\\W\\\\$\u00e2\u201a\u00ac]|$)\"]\n , prod = \\case\n (Token Numeral NumeralData { TNumeral.value = v } : Token RegexMatch (GroupMatch (match : _)) : _) ->\n case Text.toLower match of\n \"k\" -> double $ v * 1e3\n \"m\" -> double $ v * 1e6\n \"g\" -> double $ v * 1e9\n _ -> Nothing\n _ -> Nothing\n }\n\nruleNumeralsPrefixWithNegativeOrMinus :: Rule\nruleNumeralsPrefixWithNegativeOrMinus = Rule\n { name = \"numbers prefix with -, negative or minus\"\n , pattern = [regex \"-|menos|negativ(o|a)\", Predicate isPositive]\n , prod = \\case\n (_ : Token Numeral NumeralData { TNumeral.value = v } : _) ->\n double $ v * (-1)\n _ -> Nothing\n }\n\n\nrules :: [Rule]\nrules =\n [ ruleNumeralZeroToFifteen\n , ruleBelowTenWithTwoDigits\n , ruleNumeralSixteenToTwentyNine\n , ruleNumeralSixteenToNineteenWithDiez\n , ruleNumeralTwentyToNinetyTens\n , ruleNumeralTwentyOneToNinetyNine\n , ruleBigNumeral\n , ruleBigNumeralMultipliable\n , ruleNumeralMultiply\n , ruleNumeralThousandsAnd\n , ruleNumeralMillionsAnd\n , ruleTwoPartHundreds\n , ruleNumeralHundredsAndSmaller\n , ruleNumeralDotNumeral\n , ruleLeadingDotNumeral\n , ruleNumeralsSuffixesKMG\n , ruleNumeralsPrefixWithNegativeOrMinus\n ]\n", "num_lines": 357} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\nmodule Duckling.Numeral.ES.AR.Corpus (allExamples) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Numeral.Types\nimport Duckling.Testing.Types\n\nallExamples :: [Example]\nallExamples =\n concat\n [ examples (NumeralValue 1) [\"1\"]\n , examples (NumeralValue 33) [\"33\"]\n , examples (NumeralValue 1.1) [\"1,1\", \"1,10\", \"01,10\"]\n , examples (NumeralValue 0.77) [\"0,77\", \",77\"]\n , examples (NumeralValue 100000) [\"100.000\", \"100000\"]\n , examples (NumeralValue 243) [\"243\"]\n , examples (NumeralValue 3000000) [\"3000000\", \"3.000.000\"]\n , examples (NumeralValue 1200000) [\"1.200.000\", \"1200000\"]\n , examples\n (NumeralValue (-1200000))\n [\"- 1.200.000\", \"menos 1.200.000\", \"-1,2M\", \"-,0012G\"]\n , examples (NumeralValue 1.5) [\"1,5\"]\n ]\n", "num_lines": 33} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\nmodule Duckling.Numeral.ES.AR.Rules (rules) where\n\nimport Data.Maybe\nimport Data.String\nimport qualified Data.Text as Text\nimport Prelude\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers\nimport Duckling.Regex.Types\nimport Duckling.Types\n\nruleDecimalWithThousandsSeparator :: Rule\nruleDecimalWithThousandsSeparator = Rule\n { name = \"decimal with thousands separator .\"\n , pattern = [regex \"(\\\\d+(\\\\.\\\\d\\\\d\\\\d)+,\\\\d+)\"]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match : _)) : _) ->\n let fmt = Text.replace \",\" \".\" $ Text.replace \".\" Text.empty match\n in parseDouble fmt >>= double\n _ -> Nothing\n }\n\nruleDecimalNumeral :: Rule\nruleDecimalNumeral = Rule\n { name = \"decimal number ,\"\n , pattern = [regex \"(\\\\d*,\\\\d+)\"]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match : _)) : _) ->\n parseDecimal False match\n _ -> Nothing\n }\n\nruleIntegerWithThousandsSeparator :: Rule\nruleIntegerWithThousandsSeparator = Rule\n { name = \"integer with thousands separator .\"\n , pattern = [regex \"(\\\\d{1,3}(\\\\.\\\\d\\\\d\\\\d){1,5})\"]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match : _)) : _) ->\n parseDouble (Text.replace \".\" Text.empty match) >>= double\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleDecimalNumeral\n , ruleDecimalWithThousandsSeparator\n , ruleIntegerWithThousandsSeparator\n ]\n", "num_lines": 59} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\nmodule Duckling.Numeral.ES.CL.Corpus (allExamples) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Numeral.Types\nimport Duckling.Testing.Types\n\nallExamples :: [Example]\nallExamples =\n concat\n [ examples (NumeralValue 1) [\"1\"]\n , examples (NumeralValue 33) [\"33\"]\n , examples (NumeralValue 1.1) [\"1,1\", \"1,10\", \"01,10\"]\n , examples (NumeralValue 0.77) [\"0,77\", \",77\"]\n , examples (NumeralValue 100000) [\"100.000\", \"100000\"]\n , examples (NumeralValue 243) [\"243\"]\n , examples (NumeralValue 3000000) [\"3000000\", \"3.000.000\"]\n , examples (NumeralValue 1200000) [\"1.200.000\", \"1200000\"]\n , examples\n (NumeralValue (-1200000))\n [\"- 1.200.000\", \"menos 1.200.000\", \"-1,2M\", \"-,0012G\"]\n , examples (NumeralValue 1.5) [\"1,5\"]\n ]\n", "num_lines": 33} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\nmodule Duckling.Numeral.ES.CL.Rules (rules) where\n\nimport Data.Maybe\nimport Data.String\nimport qualified Data.Text as Text\nimport Prelude\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers\nimport Duckling.Regex.Types\nimport Duckling.Types\n\nruleDecimalWithThousandsSeparator :: Rule\nruleDecimalWithThousandsSeparator = Rule\n { name = \"decimal with thousands separator .\"\n , pattern = [regex \"(\\\\d+(\\\\.\\\\d\\\\d\\\\d)+,\\\\d+)\"]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match : _)) : _) ->\n let fmt = Text.replace \",\" \".\" $ Text.replace \".\" Text.empty match\n in parseDouble fmt >>= double\n _ -> Nothing\n }\n\nruleDecimalNumeral :: Rule\nruleDecimalNumeral = Rule\n { name = \"decimal number ,\"\n , pattern = [regex \"(\\\\d*,\\\\d+)\"]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match : _)) : _) ->\n parseDecimal False match\n _ -> Nothing\n }\n\nruleIntegerWithThousandsSeparator :: Rule\nruleIntegerWithThousandsSeparator = Rule\n { name = \"integer with thousands separator .\"\n , pattern = [regex \"(\\\\d{1,3}(\\\\.\\\\d\\\\d\\\\d){1,5})\"]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match : _)) : _) ->\n parseDouble (Text.replace \".\" Text.empty match) >>= double\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleDecimalNumeral\n , ruleDecimalWithThousandsSeparator\n , ruleIntegerWithThousandsSeparator\n ]\n", "num_lines": 59} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\nmodule Duckling.Numeral.ES.CO.Corpus (allExamples) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Numeral.Types\nimport Duckling.Testing.Types\n\nallExamples :: [Example]\nallExamples =\n concat\n [ examples (NumeralValue 1) [\"1\"]\n , examples (NumeralValue 33) [\"33\"]\n , examples (NumeralValue 1.1) [\"1,1\", \"1,10\", \"01,10\"]\n , examples (NumeralValue 0.77) [\"0,77\", \",77\"]\n , examples (NumeralValue 100000) [\"100.000\", \"100000\"]\n , examples (NumeralValue 243) [\"243\"]\n , examples (NumeralValue 3000000) [\"3000000\", \"3.000.000\"]\n , examples (NumeralValue 1200000) [\"1.200.000\", \"1200000\"]\n , examples\n (NumeralValue (-1200000))\n [\"- 1.200.000\", \"menos 1.200.000\", \"-1,2M\", \"-,0012G\"]\n , examples (NumeralValue 1.5) [\"1,5\"]\n ]\n", "num_lines": 33} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\nmodule Duckling.Numeral.ES.CO.Rules (rules) where\n\nimport Data.Maybe\nimport Data.String\nimport qualified Data.Text as Text\nimport Prelude\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers\nimport Duckling.Regex.Types\nimport Duckling.Types\n\nruleDecimalWithThousandsSeparator :: Rule\nruleDecimalWithThousandsSeparator = Rule\n { name = \"decimal with thousands separator .\"\n , pattern = [regex \"(\\\\d+(\\\\.\\\\d\\\\d\\\\d)+,\\\\d+)\"]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match : _)) : _) ->\n let fmt = Text.replace \",\" \".\" $ Text.replace \".\" Text.empty match\n in parseDouble fmt >>= double\n _ -> Nothing\n }\n\nruleDecimalNumeral :: Rule\nruleDecimalNumeral = Rule\n { name = \"decimal number ,\"\n , pattern = [regex \"(\\\\d*,\\\\d+)\"]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match : _)) : _) ->\n parseDecimal False match\n _ -> Nothing\n }\n\nruleIntegerWithThousandsSeparator :: Rule\nruleIntegerWithThousandsSeparator = Rule\n { name = \"integer with thousands separator .\"\n , pattern = [regex \"(\\\\d{1,3}(\\\\.\\\\d\\\\d\\\\d){1,5})\"]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match : _)) : _) ->\n parseDouble (Text.replace \".\" Text.empty match) >>= double\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleDecimalNumeral\n , ruleDecimalWithThousandsSeparator\n , ruleIntegerWithThousandsSeparator\n ]\n", "num_lines": 59} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\nmodule Duckling.Numeral.ES.ES.Corpus (allExamples) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Numeral.Types\nimport Duckling.Testing.Types\n\nallExamples :: [Example]\nallExamples =\n concat\n [ examples (NumeralValue 1) [\"1\"]\n , examples (NumeralValue 33) [\"33\"]\n , examples (NumeralValue 1.1) [\"1,1\", \"1,10\", \"01,10\"]\n , examples (NumeralValue 0.77) [\"0,77\", \",77\"]\n , examples (NumeralValue 100000) [\"100.000\", \"100000\"]\n , examples (NumeralValue 243) [\"243\"]\n , examples (NumeralValue 3000000) [\"3000000\", \"3.000.000\"]\n , examples (NumeralValue 1200000) [\"1.200.000\", \"1200000\"]\n , examples\n (NumeralValue (-1200000))\n [\"- 1.200.000\", \"menos 1.200.000\", \"-1,2M\", \"-,0012G\"]\n , examples (NumeralValue 1.5) [\"1,5\"]\n ]\n", "num_lines": 33} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\nmodule Duckling.Numeral.ES.ES.Rules\n ( rules\n , rulesBackwardCompatible\n ) where\n\nimport qualified Data.HashMap.Strict as HashMap\nimport Data.Maybe\nimport Data.String\nimport qualified Data.Text as Text\nimport Prelude\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers\nimport Duckling.Numeral.Types (NumeralData(..))\nimport qualified Duckling.Numeral.Types as TNumeral\nimport Duckling.Regex.Types\nimport Duckling.Types\n\nruleDecimalWithThousandsSeparator :: Rule\nruleDecimalWithThousandsSeparator = Rule\n { name = \"decimal with thousands separator .\"\n , pattern = [regex \"(\\\\d+(\\\\.\\\\d\\\\d\\\\d)+,\\\\d+)\"]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match : _)) : _) ->\n let fmt = Text.replace \",\" \".\" $ Text.replace \".\" Text.empty match\n in parseDouble fmt >>= double\n _ -> Nothing\n }\n\nruleDecimalNumeral :: Rule\nruleDecimalNumeral = Rule\n { name = \"decimal number ,\"\n , pattern = [regex \"(\\\\d*,\\\\d+)\"]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match : _)) : _) ->\n parseDecimal False match\n _ -> Nothing\n }\n\nruleIntegerWithThousandsSeparator :: Rule\nruleIntegerWithThousandsSeparator = Rule\n { name = \"integer with thousands separator .\"\n , pattern = [regex \"(\\\\d{1,3}(\\\\.\\\\d\\\\d\\\\d){1,5})\"]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match : _)) : _) ->\n parseDouble (Text.replace \".\" Text.empty match) >>= double\n _ -> Nothing\n }\n\nrulesBackwardCompatible :: [Rule]\nrulesBackwardCompatible =\n [ ruleDecimalNumeral\n , ruleDecimalWithThousandsSeparator\n , ruleIntegerWithThousandsSeparator\n ]\n\nrules :: [Rule]\nrules = rulesBackwardCompatible\n", "num_lines": 68} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\nmodule Duckling.Numeral.ES.MX.Corpus (allExamples) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Numeral.Types\nimport Duckling.Testing.Types\n\nallExamples :: [Example]\nallExamples =\n concat\n [ examples (NumeralValue 1) [\"1\"]\n , examples (NumeralValue 33) [\"33\"]\n , examples (NumeralValue 1.1) [\"1.1\", \"1.10\", \"01.10\"]\n , examples (NumeralValue 0.77) [\"0.77\", \".77\"]\n , examples (NumeralValue 100000) [\"100,000\", \"100000\"]\n , examples (NumeralValue 243) [\"243\"]\n , examples (NumeralValue 3000000) [\"3000000\", \"3,000,000\"]\n , examples (NumeralValue 1200000) [\"1,200,000\", \"1200000\"]\n , examples\n (NumeralValue (-1200000))\n [\"- 1,200,000\", \"menos 1,200,000\", \"-1.2M\", \"-.0012G\"]\n , examples (NumeralValue 1.5) [\"1.5\"]\n ]\n", "num_lines": 33} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\nmodule Duckling.Numeral.ES.MX.Rules (rules) where\n\nimport qualified Data.HashMap.Strict as HashMap\nimport Data.Maybe\nimport Data.String\nimport qualified Data.Text as Text\nimport Prelude\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers\nimport Duckling.Regex.Types\nimport Duckling.Types\n\nruleDecimalWithThousandsSeparator :: Rule\nruleDecimalWithThousandsSeparator = Rule\n { name = \"decimal with thousands separator\"\n , pattern = [regex \"(\\\\d+(\\\\,\\\\d\\\\d\\\\d)+\\\\.\\\\d+)\"]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match : _)) : _) ->\n parseDouble (Text.replace \",\" Text.empty match) >>= double\n _ -> Nothing\n }\n\nruleDecimalNumeral :: Rule\nruleDecimalNumeral = Rule\n { name = \"decimal number .\"\n , pattern = [regex \"(\\\\d*\\\\.\\\\d+)\"]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match : _)) : _) ->\n parseDecimal False match\n _ -> Nothing\n }\n\nruleIntegerWithThousandsSeparator :: Rule\nruleIntegerWithThousandsSeparator = Rule\n { name = \"integer with thousands separator ,\"\n , pattern = [regex \"(\\\\d{1,3}(\\\\,\\\\d\\\\d\\\\d){1,5})\"]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match : _)) : _) ->\n parseDouble (Text.replace \",\" Text.empty match) >>= double\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleDecimalNumeral\n , ruleDecimalWithThousandsSeparator\n , ruleIntegerWithThousandsSeparator\n ]\n", "num_lines": 59} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\nmodule Duckling.Numeral.ES.PE.Corpus (allExamples) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Numeral.Types\nimport Duckling.Testing.Types\n\nallExamples :: [Example]\nallExamples =\n concat\n [ examples (NumeralValue 1) [\"1\"]\n , examples (NumeralValue 33) [\"33\"]\n , examples (NumeralValue 1.1) [\"1,1\", \"1,10\", \"01,10\"]\n , examples (NumeralValue 0.77) [\"0,77\", \",77\"]\n , examples (NumeralValue 100000) [\"100.000\", \"100000\"]\n , examples (NumeralValue 243) [\"243\"]\n , examples (NumeralValue 3000000) [\"3000000\", \"3.000.000\"]\n , examples (NumeralValue 1200000) [\"1.200.000\", \"1200000\"]\n , examples\n (NumeralValue (-1200000))\n [\"- 1.200.000\", \"menos 1.200.000\", \"-1,2M\", \"-,0012G\"]\n , examples (NumeralValue 1.5) [\"1,5\"]\n ]\n", "num_lines": 33} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\nmodule Duckling.Numeral.ES.PE.Rules (rules) where\n\nimport Data.Maybe\nimport Data.String\nimport qualified Data.Text as Text\nimport Prelude\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers\nimport Duckling.Regex.Types\nimport Duckling.Types\n\nruleDecimalWithThousandsSeparator :: Rule\nruleDecimalWithThousandsSeparator = Rule\n { name = \"decimal with thousands separator .\"\n , pattern = [regex \"(\\\\d+(\\\\.\\\\d\\\\d\\\\d)+,\\\\d+)\"]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match : _)) : _) ->\n let fmt = Text.replace \",\" \".\" $ Text.replace \".\" Text.empty match\n in parseDouble fmt >>= double\n _ -> Nothing\n }\n\nruleDecimalNumeral :: Rule\nruleDecimalNumeral = Rule\n { name = \"decimal number ,\"\n , pattern = [regex \"(\\\\d*,\\\\d+)\"]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match : _)) : _) ->\n parseDecimal False match\n _ -> Nothing\n }\n\nruleIntegerWithThousandsSeparator :: Rule\nruleIntegerWithThousandsSeparator = Rule\n { name = \"integer with thousands separator .\"\n , pattern = [regex \"(\\\\d{1,3}(\\\\.\\\\d\\\\d\\\\d){1,5})\"]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match : _)) : _) ->\n parseDouble (Text.replace \".\" Text.empty match) >>= double\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleDecimalNumeral\n , ruleDecimalWithThousandsSeparator\n , ruleIntegerWithThousandsSeparator\n ]\n", "num_lines": 59} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\nmodule Duckling.Numeral.ES.VE.Corpus (allExamples) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Numeral.Types\nimport Duckling.Testing.Types\n\nallExamples :: [Example]\nallExamples =\n concat\n [ examples (NumeralValue 1) [\"1\"]\n , examples (NumeralValue 33) [\"33\"]\n , examples (NumeralValue 1.1) [\"1,1\", \"1,10\", \"01,10\"]\n , examples (NumeralValue 0.77) [\"0,77\", \",77\"]\n , examples (NumeralValue 100000) [\"100.000\", \"100000\"]\n , examples (NumeralValue 243) [\"243\"]\n , examples (NumeralValue 3000000) [\"3000000\", \"3.000.000\"]\n , examples (NumeralValue 1200000) [\"1.200.000\", \"1200000\"]\n , examples\n (NumeralValue (-1200000))\n [\"- 1.200.000\", \"menos 1.200.000\", \"-1,2M\", \"-,0012G\"]\n , examples (NumeralValue 1.5) [\"1,5\"]\n ]\n", "num_lines": 33} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\nmodule Duckling.Numeral.ES.VE.Rules (rules) where\n\nimport Data.Maybe\nimport Data.String\nimport qualified Data.Text as Text\nimport Prelude\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers\nimport Duckling.Regex.Types\nimport Duckling.Types\n\nruleDecimalWithThousandsSeparator :: Rule\nruleDecimalWithThousandsSeparator = Rule\n { name = \"decimal with thousands separator .\"\n , pattern = [regex \"(\\\\d+(\\\\.\\\\d\\\\d\\\\d)+,\\\\d+)\"]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match : _)) : _) ->\n let fmt = Text.replace \",\" \".\" $ Text.replace \".\" Text.empty match\n in parseDouble fmt >>= double\n _ -> Nothing\n }\n\nruleDecimalNumeral :: Rule\nruleDecimalNumeral = Rule\n { name = \"decimal number ,\"\n , pattern = [regex \"(\\\\d*,\\\\d+)\"]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match : _)) : _) ->\n parseDecimal False match\n _ -> Nothing\n }\n\nruleIntegerWithThousandsSeparator :: Rule\nruleIntegerWithThousandsSeparator = Rule\n { name = \"integer with thousands separator .\"\n , pattern = [regex \"(\\\\d{1,3}(\\\\.\\\\d\\\\d\\\\d){1,5})\"]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match : _)) : _) ->\n parseDouble (Text.replace \".\" Text.empty match) >>= double\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleDecimalNumeral\n , ruleDecimalWithThousandsSeparator\n , ruleIntegerWithThousandsSeparator\n ]\n", "num_lines": 59} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Numeral.ET.Corpus\n ( corpus ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Locale\nimport Duckling.Numeral.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale ET Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (NumeralValue 0)\n [ \"0\"\n , \"null\"\n ]\n , examples (NumeralValue 1)\n [ \"1\"\n , \"\u00c3\u00bcks\"\n ]\n , examples (NumeralValue 33)\n [ \"33\"\n , \"Kolmk\u00c3\u00bcmmend kolm\"\n ]\n , examples (NumeralValue 14)\n [ \"14\"\n , \"neliteist\"\n ]\n , examples (NumeralValue 16)\n [ \"16\"\n , \"kuusteist\"\n ]\n , examples (NumeralValue 17)\n [ \"17\"\n , \"Seitseteist\"\n ]\n , examples (NumeralValue 18)\n [ \"18\"\n , \"kaheksateist\"\n ]\n , examples (NumeralValue 1.1)\n [ \"1.1\"\n , \"1.10\"\n , \"01.10\"\n ]\n , examples (NumeralValue 0.77)\n [ \"0.77\"\n , \".77\"\n ]\n , examples (NumeralValue 100000)\n [ \"100,000\"\n , \"100000\"\n , \"100K\"\n , \"100k\"\n , \"100 000\"\n ]\n , examples (NumeralValue 3000000)\n [ \"3M\"\n , \"3000K\"\n , \"3000000\"\n , \"3,000,000\"\n , \"3 000 000\"\n ]\n , examples (NumeralValue 1200000)\n [ \"1,200,000\"\n , \"1200000\"\n , \"1.2M\"\n , \"1200K\"\n , \".0012G\"\n , \"1 200 000\"\n ]\n , examples (NumeralValue (-1200000))\n [ \"- 1,200,000\"\n , \"-1200000\"\n , \"miinus 1,200,000\"\n , \"-1.2M\"\n , \"-1200K\"\n , \"-.0012G\"\n ]\n , examples (NumeralValue 5000)\n [ \"viis tuhat\"\n ]\n , examples (NumeralValue 200000)\n [ \"kakssada tuhat\"\n ]\n , examples (NumeralValue 21011)\n [ \"kaksk\u00c3\u00bcmmend \u00c3\u00bcks Tuhat \u00c3\u00bcksteist\"\n ]\n , examples (NumeralValue 721012)\n [ \"seitsesada kaksk\u00c3\u00bcmmend \u00c3\u00bcks tuhat kaksteist\"\n ]\n , examples (NumeralValue 31256721)\n [ \"kolmk\u00c3\u00bcmmend \u00c3\u00bcks miljonit kakssada viisk\u00c3\u00bcmmend kuus tuhat seitsesada kaksk\u00c3\u00bcmmend \u00c3\u00bcks\"\n ]\n ]\n", "num_lines": 109} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Numeral.ET.Rules\n ( rules\n ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport Data.Maybe\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers\nimport Duckling.Numeral.Types (NumeralData (..))\nimport Duckling.Regex.Types\nimport Duckling.Types\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleNumeralsPrefixWithNegativeOrMinus :: Rule\nruleNumeralsPrefixWithNegativeOrMinus = Rule\n { name = \"numbers prefix with -, negative or minus\"\n , pattern =\n [ regex \"-|miinus|negatiivne\"\n , Predicate isPositive\n ]\n , prod = \\tokens -> case tokens of\n (_:\n Token Numeral NumeralData{TNumeral.value = v}:\n _) -> double $ v * (-1)\n _ -> Nothing\n }\n\nruleACoupleOf :: Rule\nruleACoupleOf = Rule\n { name = \"a couple of\"\n , pattern =\n [ regex \"paar\"\n ]\n , prod = \\_ -> integer 2\n }\n\nruleTen :: Rule\nruleTen = Rule\n { name = \"ten\"\n , pattern =\n [ regex \"k\u00c3\u00bcmme\"\n ]\n , prod = \\_ -> integer 10 >>= withGrain 1\n }\n\nruleDecimalWithThousandsSeparator :: Rule\nruleDecimalWithThousandsSeparator = Rule\n { name = \"decimal with thousands separator\"\n , pattern =\n [ regex \"(\\\\d+(,\\\\d\\\\d\\\\d)+\\\\.\\\\d+)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n parseDouble (Text.replace (Text.singleton ',') Text.empty match) >>= double\n _ -> Nothing\n }\n\nruleDecimalNumeral :: Rule\nruleDecimalNumeral = Rule\n { name = \"decimal number\"\n , pattern =\n [ regex \"(\\\\d*\\\\.\\\\d+)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> parseDecimal True match\n _ -> Nothing\n }\n\nruleInteger3 :: Rule\nruleInteger3 = Rule\n { name = \"integer 21..99\"\n , pattern =\n [ oneOf [70, 20, 60, 50, 40, 90, 30, 80]\n , Predicate $ numberBetween 1 10\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v1}:\n Token Numeral NumeralData{TNumeral.value = v2}:_) -> double $ v1 + v2\n _ -> Nothing\n }\n\nruleAFew :: Rule\nruleAFew = Rule\n { name = \"(a )?few\"\n , pattern =\n [ regex \"m\u00c3\u00b5ni\"\n ]\n , prod = \\_ -> integer 3\n }\n\nrulePowersOfTen :: Rule\nrulePowersOfTen = Rule\n { name = \"powers of tens\"\n , pattern = [regex \"(sada|tuhat|miljoni?t?)\"]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of\n \"sada\" -> double 1e2 >>= withGrain 2 >>= withMultipliable\n \"tuhat\" -> double 1e3 >>= withGrain 3 >>= withMultipliable\n _ -> double 1e6 >>= withGrain 6 >>= withMultipliable\n _ -> Nothing\n }\n\nruleIntersect :: Rule\nruleIntersect = Rule\n { name = \"intersect\"\n , pattern =\n [ Predicate hasGrain\n , Predicate $ and . sequence [not . isMultipliable, isPositive]\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = val1, TNumeral.grain = Just g}:\n Token Numeral NumeralData{TNumeral.value = val2}:\n _) | (10 ** fromIntegral g) > val2 -> double $ val1 + val2\n _ -> Nothing\n }\n\nruleNumeralsSuffixesKMG :: Rule\nruleNumeralsSuffixesKMG = Rule\n { name = \"numbers suffixes (K, M, G)\"\n , pattern =\n [ dimension Numeral\n , regex \"([kmg])(?=[\\\\W\\\\$\u00e2\u201a\u00ac]|$)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v}:\n Token RegexMatch (GroupMatch (match:_)):\n _) -> case Text.toLower match of\n \"k\" -> double $ v * 1e3\n \"m\" -> double $ v * 1e6\n \"g\" -> double $ v * 1e9\n _ -> Nothing\n _ -> Nothing\n }\n\nruleMultiply :: Rule\nruleMultiply = Rule\n { name = \"compose by multiplication\"\n , pattern =\n [ dimension Numeral\n , Predicate isMultipliable\n ]\n , prod = \\tokens -> case tokens of\n (token1:token2:_) -> multiply token1 token2\n _ -> Nothing\n }\n\nzeroNineteenMap :: HashMap Text Integer\nzeroNineteenMap = HashMap.fromList\n [ (\"null\", 0)\n , (\"\u00c3\u00bcks\", 1)\n , (\"kaks\", 2)\n , (\"kolm\", 3)\n , (\"neli\", 4)\n , (\"viis\", 5)\n , (\"kuus\", 6)\n , (\"seitse\", 7)\n , (\"kaheksa\", 8)\n , (\"\u00c3\u00bcheksa\", 9)\n , (\"k\u00c3\u00bcmme\", 10)\n , (\"\u00c3\u00bcksteist\", 11)\n , (\"kaksteist\", 12)\n , (\"kolmteist\", 13)\n , (\"neliteist\", 14)\n , (\"viisteist\", 15)\n , (\"kuusteist\", 16)\n , (\"seitseteist\", 17)\n , (\"kaheksateist\", 18)\n , (\"\u00c3\u00bcheksateist\", 19)\n ]\n\nruleInteger :: Rule\nruleInteger = Rule\n { name = \"integer (0..19)\"\n , pattern =\n [ regex \"(null|\u00c3\u00bcksteist|\u00c3\u00bcks|kaksteist|kaks|kolmteist|kolm|neliteist|neli|viisteist|viis|kuusteist|kuus|seitseteist|seitse|kaheksateist|kaheksa|\u00c3\u00bcheksateist|\u00c3\u00bcheksa|k\u00c3\u00bcmme)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) zeroNineteenMap >>= integer\n _ -> Nothing\n }\n\nruleInteger4 :: Rule\nruleInteger4 = Rule\n { name = \"integer (200..900)\"\n , pattern =\n [ regex \"(kakssada|kolmsada|nelisada|viissada|kuussada|seitsesada|kaheksasada|\u00c3\u00bcheksasada)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of\n \"kakssada\" -> integer 200 >>= withGrain 2 >>= withMultipliable\n \"kolmsada\" -> integer 300 >>= withGrain 2 >>= withMultipliable\n \"nelisada\" -> integer 400 >>= withGrain 2 >>= withMultipliable\n \"viissada\" -> integer 500 >>= withGrain 2 >>= withMultipliable\n \"kuussada\" -> integer 600 >>= withGrain 2 >>= withMultipliable\n \"seitsesada\" -> integer 700 >>= withGrain 2 >>= withMultipliable\n \"kaheksasada\" -> integer 800 >>= withGrain 2 >>= withMultipliable\n \"\u00c3\u00bcheksasada\" -> integer 900 >>= withGrain 2 >>= withMultipliable\n _ -> Nothing\n _ -> Nothing\n }\n\ntwentyNinetyMap :: HashMap Text Integer\ntwentyNinetyMap = HashMap.fromList\n [ (\"kaksk\u00c3\u00bcmmend\", 20)\n , (\"kolmk\u00c3\u00bcmmend\", 30)\n , (\"nelik\u00c3\u00bcmmend\", 40)\n , (\"viisk\u00c3\u00bcmmend\", 50)\n , (\"kuusk\u00c3\u00bcmmend\", 60)\n , (\"seitsek\u00c3\u00bcmmend\", 70)\n , (\"kaheksak\u00c3\u00bcmmend\", 80)\n , (\"\u00c3\u00bcheksak\u00c3\u00bcmmend\", 90)\n ]\n\nruletwentyNinety :: Rule\nruletwentyNinety = Rule\n { name = \"integer (20..90)\"\n , pattern =\n [ regex \"((kaks|kolm|neli|viis|kuus|seitse|kaheksa|(\u00c3\u00bc)heksa)k(\u00c3\u00bc)mmend)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) twentyNinetyMap >>= integer\n _ -> Nothing\n }\n\nruleNumeralDotNumeral :: Rule\nruleNumeralDotNumeral = Rule\n { name = \"number dot number\"\n , pattern =\n [ dimension Numeral\n , regex \"dot|point\"\n , Predicate $ not . hasGrain\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v1}:\n _:\n Token Numeral NumeralData{TNumeral.value = v2}:\n _) -> double $ v1 + decimalsToDouble v2\n _ -> Nothing\n }\n\nruleIntegerWithThousandsSeparator :: Rule\nruleIntegerWithThousandsSeparator = Rule\n { name = \"integer with thousands separator ,\"\n , pattern =\n [ regex \"(\\\\d{1,3}(([, ])\\\\d\\\\d\\\\d){1,5})\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_:sep:_)):_) ->\n parseDouble (Text.replace sep Text.empty match) >>= double\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleACoupleOf\n , ruleAFew\n , ruleDecimalNumeral\n , ruleDecimalWithThousandsSeparator\n , ruleInteger\n , ruletwentyNinety\n , ruleInteger3\n , ruleInteger4\n , ruleIntegerWithThousandsSeparator\n , ruleIntersect\n , ruleMultiply\n , ruleNumeralDotNumeral\n , ruleNumeralsPrefixWithNegativeOrMinus\n , ruleNumeralsSuffixesKMG\n , rulePowersOfTen\n , ruleTen\n ]\n", "num_lines": 290} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Numeral.FI.Corpus\n ( corpus\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Locale\nimport Duckling.Numeral.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncontext :: Context\ncontext = testContext {locale = makeLocale FI Nothing}\n\ncorpus :: Corpus\ncorpus = (context, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (NumeralValue 0)\n [ \"0\"\n , \"nolla\"\n ]\n , examples (NumeralValue 1)\n [ \"1\"\n , \"yksi\"\n ]\n , examples (NumeralValue 2)\n [ \"kaksi\"\n ]\n , examples (NumeralValue 3)\n [ \"kolme\"\n ]\n , examples (NumeralValue 4)\n [ \"nelj\u00c3\u00a4\"\n ]\n , examples (NumeralValue 5)\n [ \"viisi\"\n ]\n , examples (NumeralValue 6)\n [ \"kuusi\"\n ]\n , examples (NumeralValue 7)\n [ \"seitsem\u00c3\u00a4n\"\n ]\n , examples (NumeralValue 8)\n [ \"kahdeksan\"\n ]\n , examples (NumeralValue 9)\n [ \"yhdeks\u00c3\u00a4n\"\n ]\n , examples (NumeralValue 10)\n [ \"10\"\n , \"kymmenen\"\n ]\n , examples (NumeralValue 11)\n [ \"yksitoista\"\n ]\n , examples (NumeralValue 12)\n [ \"kaksitoista\"\n ]\n , examples (NumeralValue 13)\n [ \"kolmetoista\"\n ]\n , examples (NumeralValue 14)\n [ \"nelj\u00c3\u00a4toista\"\n ]\n , examples (NumeralValue 15)\n [ \"viisitoista\"\n ]\n , examples (NumeralValue 16)\n [ \"kuusitoista\"\n ]\n , examples (NumeralValue 17)\n [ \"seitsem\u00c3\u00a4ntoista\"\n ]\n , examples (NumeralValue 18)\n [ \"kahdeksantoista\"\n ]\n , examples (NumeralValue 19)\n [ \"yhdeks\u00c3\u00a4ntoista\"\n ]\n , examples (NumeralValue 20)\n [ \"20\"\n , \"kaksikymment\u00c3\u00a4\"\n ]\n , examples (NumeralValue 24)\n [ \"24\"\n , \"kaksikymment\u00c3\u00a4nelj\u00c3\u00a4\"\n ]\n , examples (NumeralValue 35)\n [ \"kolmekymment\u00c3\u00a4viisi\"\n ]\n , examples (NumeralValue 42)\n [ \"nelj\u00c3\u00a4kymment\u00c3\u00a4kaksi\"\n ]\n , examples (NumeralValue 52)\n [ \"viisikymment\u00c3\u00a4kaksi\"\n ]\n , examples (NumeralValue 62)\n [ \"kuusikymment\u00c3\u00a4kaksi\"\n ]\n , examples (NumeralValue 72)\n [ \"seitsem\u00c3\u00a4nkymment\u00c3\u00a4kaksi\"\n ]\n , examples (NumeralValue 82)\n [ \"kahdeksankymment\u00c3\u00a4kaksi\"\n ]\n , examples (NumeralValue 99)\n [ \"99\"\n , \"yhdeks\u00c3\u00a4nkymment\u00c3\u00a4yhdeks\u00c3\u00a4n\"\n ]\n ]\n", "num_lines": 123} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n{-# LANGUAGE NoRebindableSyntax #-}\n\nmodule Duckling.Numeral.FI.Rules\n ( rules\n ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport Data.Maybe\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers\nimport Duckling.Numeral.Types (NumeralData(..))\nimport Duckling.Regex.Types\nimport Duckling.Types\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleIntegerNumeric :: Rule\nruleIntegerNumeric = Rule\n { name = \"integer (numeric)\"\n , pattern =\n [ regex \"(\\\\d{1,18})\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):_) -> do\n v <- parseInt match\n integer $ toInteger v\n _ -> Nothing\n }\n\nnumeralMap :: HashMap Text Integer\nnumeralMap = HashMap.fromList\n [ ( \"nolla\", 0 )\n , ( \"yksi\", 1 )\n , ( \"kaksi\", 2 )\n , ( \"kolme\", 3 )\n , ( \"nelj\u00c3\u00a4\", 4 )\n , ( \"viisi\", 5 )\n , ( \"kuusi\", 6 )\n , ( \"seitsem\u00c3\u00a4n\", 7 )\n , ( \"kahdeksan\", 8 )\n , ( \"yhdeks\u00c3\u00a4n\", 9 )\n , ( \"kymmenen\", 10 )\n ]\n\nruleNumeral :: Rule\nruleNumeral = Rule\n { name = \"number (0..10)\"\n , pattern =\n [ regex \"(nolla|yksi|kaksi|kolme|nelj\u00c3\u00a4|viisi|kuusi|seitsem\u00c3\u00a4n|kahdeksan|yhdeks\u00c3\u00a4n|kymmenen)\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) numeralMap >>= integer\n _ -> Nothing\n }\n\nelevenToNineteenMap :: HashMap Text Integer\nelevenToNineteenMap = HashMap.fromList\n [ ( \"yksitoista\", 11 )\n , ( \"kaksitoista\", 12 )\n , ( \"kolmetoista\", 13 )\n , ( \"nelj\u00c3\u00a4toista\", 14 )\n , ( \"viisitoista\", 15 )\n , ( \"kuusitoista\", 16 )\n , ( \"seitsem\u00c3\u00a4ntoista\", 17 )\n , ( \"kahdeksantoista\", 18 )\n , ( \"yhdeks\u00c3\u00a4ntoista\", 19 )\n ]\n\nruleElevenToNineteen :: Rule\nruleElevenToNineteen = Rule\n { name = \"number (11..19)\"\n , pattern =\n [ regex \"(yksitoista|kaksitoista|kolmetoista|nelj\u00c3\u00a4toista|viisitoista|kuusitoista|seitsem\u00c3\u00a4ntoista|kahdeksantoista|yhdeks\u00c3\u00a4ntoista)\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) elevenToNineteenMap >>= integer\n _ -> Nothing\n }\n\ntensMap :: HashMap Text Integer\ntensMap = HashMap.fromList\n [ ( \"kaksikymment\u00c3\u00a4\", 20 )\n , ( \"kolmekymment\u00c3\u00a4\", 30 )\n , ( \"nelj\u00c3\u00a4kymment\u00c3\u00a4\", 40 )\n , ( \"viisikymment\u00c3\u00a4\", 50 )\n , ( \"kuusikymment\u00c3\u00a4\", 60 )\n , ( \"seitsem\u00c3\u00a4nkymment\u00c3\u00a4\", 70 )\n , ( \"kahdeksankymment\u00c3\u00a4\", 80 )\n , ( \"yhdeks\u00c3\u00a4nkymment\u00c3\u00a4\", 90 )\n ]\n\nruleTens :: Rule\nruleTens = Rule\n { name = \"integer (20,30..90)\"\n , pattern =\n [ regex \"(kaksikymment\u00c3\u00a4|kolmekymment\u00c3\u00a4|nelj\u00c3\u00a4kymment\u00c3\u00a4|viisikymment\u00c3\u00a4|kuusikymment\u00c3\u00a4|seitsem\u00c3\u00a4nkymment\u00c3\u00a4|kahdeksankymment\u00c3\u00a4|yhdeks\u00c3\u00a4nkymment\u00c3\u00a4)\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) tensMap >>= integer\n _ -> Nothing\n }\n\nruleCompositeTens :: Rule\nruleCompositeTens = Rule\n { name = \"integer ([2-9][1-9])\"\n , pattern =\n [ regex \"(kaksikymment\u00c3\u00a4|kolmekymment\u00c3\u00a4|nelj\u00c3\u00a4kymment\u00c3\u00a4|viisikymment\u00c3\u00a4|kuusikymment\u00c3\u00a4|seitsem\u00c3\u00a4nkymment\u00c3\u00a4|kahdeksankymment\u00c3\u00a4|yhdeks\u00c3\u00a4nkymment\u00c3\u00a4)(yksi|kaksi|kolme|nelj\u00c3\u00a4|viisi|kuusi|seitsem\u00c3\u00a4n|kahdeksan|yhdeks\u00c3\u00a4n)\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (m1:m2:_)):_) -> do\n v1 <- HashMap.lookup (Text.toLower m1) tensMap\n v2 <- HashMap.lookup (Text.toLower m2) numeralMap\n integer $ v1 + v2\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleIntegerNumeric\n , ruleNumeral\n , ruleElevenToNineteen\n , ruleTens\n , ruleCompositeTens\n ]\n", "num_lines": 142} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Numeral.FR.Corpus\n ( corpus\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Locale\nimport Duckling.Numeral.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale FR Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (NumeralValue 0)\n [ \"0\"\n , \"zero\"\n , \"z\u00c3\u00a9ro\"\n ]\n , examples (NumeralValue 1)\n [ \"1\"\n , \"un\"\n , \"une\"\n ]\n , examples (NumeralValue 11)\n [ \"onze\"\n ]\n , examples (NumeralValue 17)\n [ \"dix sept\"\n , \"dix-sept\"\n ]\n , examples (NumeralValue 21)\n [ \"vingt et un\"\n , \"vingt-et-un\"\n ]\n , examples (NumeralValue 23)\n [ \"vingt trois\"\n , \"vingt-trois\"\n ]\n , examples (NumeralValue 70)\n [ \"soixante dix\"\n ]\n , examples (NumeralValue 71)\n [ \"soixante onze\"\n ]\n , examples (NumeralValue 78)\n [ \"soixante dix huit\"\n ]\n , examples (NumeralValue 73)\n [ \"soixante treize\"\n ]\n , examples (NumeralValue 80)\n [ \"quatre vingt\"\n ]\n , examples (NumeralValue 81)\n [ \"quatre vingt un\"\n ]\n , examples (NumeralValue 82)\n [ \"quatre vingt deux\"\n ]\n , examples (NumeralValue 90)\n [ \"quatre vingt dix\"\n ]\n , examples (NumeralValue 91)\n [ \"quatre vingt onze\"\n ]\n , examples (NumeralValue 92)\n [ \"quatre vingt douze\"\n ]\n , examples (NumeralValue 99)\n [ \"quatre vingt dix neuf\"\n ]\n , examples (NumeralValue 33)\n [ \"33\"\n , \"trente trois\"\n , \"trente-trois\"\n , \"trente 3\"\n ]\n , examples (NumeralValue 118)\n [ \"cent dix-huit\"\n ]\n , examples (NumeralValue 4020)\n [ \"quatre mille vingt\"\n ]\n , examples (NumeralValue 100000)\n [ \"100.000\"\n , \"100000\"\n , \"100K\"\n , \"100k\"\n , \"cent mille\"\n , \"100 000\"\n ]\n , examples (NumeralValue 3000000)\n [ \"3M\"\n , \"3000K\"\n , \"3000000\"\n , \"3.000.000\"\n , \"trois millions\"\n ]\n , examples (NumeralValue 1200000)\n [ \"1.200.000\"\n , \"1200000\"\n , \"1,2M\"\n , \"1200K\"\n , \",0012G\"\n , \"un million deux cent mille\"\n ]\n , examples (NumeralValue (-1200000))\n [ \"- 1.200.000\"\n , \"-1200000\"\n , \"moins 1200000\"\n , \"-1,2M\"\n , \"-1200K\"\n , \"-,0012G\"\n ]\n , examples (NumeralValue 6.7)\n [ \"6,7\"\n ]\n , examples (NumeralValue 6700.54)\n [ \"6.700,54\"\n , \"6 700,54\"\n ]\n ]\n", "num_lines": 136} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Numeral.FR.Rules\n ( rules\n ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport Data.Maybe\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers\nimport Duckling.Numeral.Types (NumeralData (..))\nimport Duckling.Regex.Types\nimport Duckling.Types\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleNumerals4 :: Rule\nruleNumerals4 = Rule\n { name = \"numbers 81\"\n , pattern =\n [ numberWith TNumeral.value (== 80)\n , numberWith TNumeral.value (== 1)\n ]\n , prod = \\_ -> integer 81\n }\n\nruleNumeralsPrefixWithNegativeOrMinus :: Rule\nruleNumeralsPrefixWithNegativeOrMinus = Rule\n { name = \"numbers prefix with -, negative or minus\"\n , pattern =\n [ regex \"-|moins\"\n , dimension Numeral\n ]\n , prod = \\tokens -> case tokens of\n (_:\n Token Numeral NumeralData{TNumeral.value = v}:\n _) -> double $ v * (-1)\n _ -> Nothing\n }\n\nruleNumerals2 :: Rule\nruleNumerals2 = Rule\n { name = \"numbers 22..29 32..39 .. 52..59\"\n , pattern =\n [ oneOf [20, 50, 40, 30]\n , regex \"[\\\\s\\\\-]+\"\n , Predicate $ numberBetween 2 10\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v1}:\n _:\n Token Numeral NumeralData{TNumeral.value = v2}:\n _) -> double $ v1 + v2\n _ -> Nothing\n }\n\nruleDecimalWithThousandsSeparator :: Rule\nruleDecimalWithThousandsSeparator = Rule\n { name = \"decimal with thousands separator\"\n , pattern =\n [ regex \"(\\\\d+(([\\\\. ])\\\\d\\\\d\\\\d)+,\\\\d+)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_:sep:_)):\n _) -> let fmt = Text.replace \",\" \".\" $ Text.replace sep Text.empty match\n in parseDouble fmt >>= double\n _ -> Nothing\n }\n\nruleDecimalNumeral :: Rule\nruleDecimalNumeral = Rule\n { name = \"decimal number\"\n , pattern =\n [ regex \"(\\\\d*,\\\\d+)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):\n _) -> parseDecimal False match\n _ -> Nothing\n }\n\nruleNumeral2Map :: HashMap Text Integer\nruleNumeral2Map = HashMap.fromList\n [ ( \"vingt\" , 20 )\n , ( \"trente\" , 30 )\n , ( \"quarante\" , 40 )\n , ( \"cinquante\", 50 )\n , ( \"soixante\" , 60 )\n ]\n\nruleNumeral2 :: Rule\nruleNumeral2 = Rule\n { name = \"number (20..60)\"\n , pattern =\n [ regex \"(vingt|trente|quarante|cinquante|soixante)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) ruleNumeral2Map >>= integer\n _ -> Nothing\n }\n\nruleNumerals5 :: Rule\nruleNumerals5 = Rule\n { name = \"numbers 62..69 .. 92..99\"\n , pattern =\n [ oneOf [60, 80]\n , regex \"[\\\\s\\\\-]+\"\n , Predicate $ numberBetween 2 20\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v1}:\n _:\n Token Numeral NumeralData{TNumeral.value = v2}:\n _) -> double $ v1 + v2\n _ -> Nothing\n }\n\nruleNumeralMap :: HashMap Text Integer\nruleNumeralMap = HashMap.fromList\n [ ( \"zero\" , 0 )\n , ( \"z\u00c3\u00a9ro\" , 0 )\n , ( \"un\" , 1 )\n , ( \"une\" , 1 )\n , ( \"deux\" , 2 )\n , ( \"trois\" , 3 )\n , ( \"quatre\" , 4 )\n , ( \"cinq\" , 5 )\n , ( \"six\" , 6 )\n , ( \"sept\" , 7 )\n , ( \"huit\" , 8 )\n , ( \"neuf\" , 9 )\n , ( \"dix\" , 10 )\n , ( \"onze\" , 11 )\n , ( \"douze\" , 12 )\n , ( \"treize\" , 13 )\n , ( \"quatorze\" , 14 )\n , ( \"quinze\" , 15 )\n , ( \"seize\" , 16 )\n ]\n\nruleNumeral :: Rule\nruleNumeral = Rule\n { name = \"number (0..16)\"\n , pattern =\n [ regex \"(z(e|\u00c3\u00a9)ro|une?|deux|trois|quatre|cinq|six|sept|huit|neuf|dix|onze|douze|treize|quatorze|quinze|seize)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) ruleNumeralMap >>= integer\n _ -> Nothing\n }\n\nruleNumeral3 :: Rule\nruleNumeral3 = Rule\n { name = \"number (17..19)\"\n , pattern =\n [ numberWith TNumeral.value (== 10)\n , regex \"[\\\\s\\\\-]+\"\n , Predicate $ numberBetween 7 10\n ]\n , prod = \\tokens -> case tokens of\n (_:\n _:\n Token Numeral NumeralData{TNumeral.value = v}:\n _) -> double $ 10 + v\n _ -> Nothing\n }\n\nruleNumerals3 :: Rule\nruleNumerals3 = Rule\n { name = \"numbers 61 71\"\n , pattern =\n [ numberWith TNumeral.value (== 60)\n , regex \"-?et-?\"\n , oneOf [1, 11]\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v1}:\n _:\n Token Numeral NumeralData{TNumeral.value = v2}:\n _) -> double $ v1 + v2\n _ -> Nothing\n }\n\nruleNumeralsSuffixesKMG :: Rule\nruleNumeralsSuffixesKMG = Rule\n { name = \"numbers suffixes (K, M, G)\"\n , pattern =\n [ dimension Numeral\n , regex \"([kmg])(?=[\\\\W$\u00e2\u201a\u00ac\u00c2\u00a2\u00c2\u00a3]|$)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v}:\n Token RegexMatch (GroupMatch (match:_)):\n _) -> case Text.toLower match of\n \"k\" -> double $ v * 1e3\n \"m\" -> double $ v * 1e6\n \"g\" -> double $ v * 1e9\n _ -> Nothing\n _ -> Nothing\n }\n\nruleNumeral4 :: Rule\nruleNumeral4 = Rule\n { name = \"number 80\"\n , pattern =\n [ regex \"quatre\"\n , regex \"vingts?\"\n ]\n , prod = \\_ -> integer 80\n }\n\nruleNumerals :: Rule\nruleNumerals = Rule\n { name = \"numbers 21 31 41 51\"\n , pattern =\n [ oneOf [20, 50, 40, 30]\n , regex \"-?et-?\"\n , numberWith TNumeral.value (== 1)\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v1}:\n _:\n Token Numeral NumeralData{TNumeral.value = v2}:\n _) -> double $ v1 + v2\n _ -> Nothing\n }\n\nruleIntegerWithThousandsSeparator :: Rule\nruleIntegerWithThousandsSeparator = Rule\n { name = \"integer with thousands separator .\"\n , pattern =\n [ regex \"(\\\\d{1,3}(([\\\\. ])\\\\d\\\\d\\\\d){1,5})\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_:sep:_)):\n _) -> let fmt = Text.replace sep Text.empty match\n in parseDouble fmt >>= double\n _ -> Nothing\n }\n\nrulePowersOfTen :: Rule\nrulePowersOfTen = Rule\n { name = \"powers of tens\"\n , pattern =\n [ regex \"(cent|mille|millions?|milliards?)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of\n \"cent\" -> double 1e2 >>= withGrain 2 >>= withMultipliable\n \"mille\" -> double 1e3 >>= withGrain 3 >>= withMultipliable\n \"million\" -> double 1e6 >>= withGrain 6 >>= withMultipliable\n \"millions\" -> double 1e6 >>= withGrain 6 >>= withMultipliable\n \"milliard\" -> double 1e9 >>= withGrain 9 >>= withMultipliable\n \"milliards\" -> double 1e9 >>= withGrain 9 >>= withMultipliable\n _ -> Nothing\n _ -> Nothing\n }\n\nruleSum :: Rule\nruleSum = Rule\n { name = \"intersect 2 numbers\"\n , pattern =\n [ Predicate hasGrain\n , Predicate $ and . sequence [not . isMultipliable, isPositive]\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = val1, TNumeral.grain = Just g}:\n Token Numeral NumeralData{TNumeral.value = val2}:\n _) | (10 ** fromIntegral g) > val2 -> double $ val1 + val2\n _ -> Nothing\n }\n\nruleMultiply :: Rule\nruleMultiply = Rule\n { name = \"compose by multiplication\"\n , pattern =\n [ dimension Numeral\n , Predicate isMultipliable\n ]\n , prod = \\tokens -> case tokens of\n (token1:token2:_) -> multiply token1 token2\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleDecimalNumeral\n , ruleDecimalWithThousandsSeparator\n , ruleIntegerWithThousandsSeparator\n , ruleNumeral\n , ruleNumeral2\n , ruleNumeral3\n , ruleNumeral4\n , ruleNumerals\n , ruleNumerals2\n , ruleNumerals3\n , ruleNumerals4\n , ruleNumerals5\n , ruleNumeralsPrefixWithNegativeOrMinus\n , ruleNumeralsSuffixesKMG\n , rulePowersOfTen\n , ruleSum\n , ruleMultiply\n ]\n", "num_lines": 320} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Numeral.GA.Corpus\n ( corpus\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Locale\nimport Duckling.Numeral.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale GA Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (NumeralValue 0)\n [ \"0\"\n , \"a n\u00c3\u00a1id\"\n ]\n , examples (NumeralValue 1)\n [ \"1\"\n , \"aon\"\n , \"a haon\"\n , \"Amh\u00c3\u00a1in\"\n ]\n , examples (NumeralValue 20)\n [ \"20\"\n , \"Fiche\"\n ]\n , examples (NumeralValue 30)\n [ \"d\u00c3\u00a9ag is fiche\"\n ]\n , examples (NumeralValue 40)\n [ \"is dha fhichead\"\n , \"is d\u00c3\u00a1 fhichead\"\n ]\n , examples (NumeralValue 50)\n [ \"deag is dha fhichead\"\n , \"deag is d\u00c3\u00a1 fhichead\"\n ]\n ]\n", "num_lines": 53} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE NoRebindableSyntax #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Numeral.GA.Rules\n ( rules\n ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers\nimport Duckling.Numeral.Types (NumeralData (..))\nimport Duckling.Regex.Types\nimport Duckling.Types\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleNumeralsPrefixWithNegativeOrMinus :: Rule\nruleNumeralsPrefixWithNegativeOrMinus = Rule\n { name = \"numbers prefix with -, negative or minus\"\n , pattern =\n [ regex \"-|m(\u00c3\u00ad|i)neas(\\\\sa)?\"\n , Predicate isPositive\n ]\n , prod = \\tokens -> case tokens of\n (_:\n Token Numeral NumeralData{TNumeral.value = v}:\n _) -> double $ v * (-1)\n _ -> Nothing\n }\n\noneToTenMap :: HashMap Text Integer\noneToTenMap = HashMap.fromList\n [ (\"aon\", 1)\n , (\"dha\", 2)\n , (\"dh\u00c3\u00a1\", 2)\n , (\"tr\u00c3\u00ad\", 3)\n , (\"tri\", 3)\n , (\"ceithre\", 4)\n , (\"cuig\", 5)\n , (\"c\u00c3\u00baig\", 5)\n , (\"s\u00c3\u00a9\", 6)\n , (\"se\", 6)\n , (\"seacht\", 7)\n , (\"ocht\", 8)\n , (\"naoi\", 9)\n , (\"deich\", 10)\n ]\n\nruleNumerals2 :: Rule\nruleNumerals2 = Rule\n { name = \"numbers, 1-10\"\n , pattern =\n [ regex \"(aon|dh(\u00c3\u00a1|a)|tr(\u00c3\u00ad|i)|ceithre|c(\u00c3\u00ba|u)ig|seacht|s(\u00c3\u00a9|e)|ocht|naoi|deich)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) oneToTenMap >>= integer\n _ -> Nothing\n }\n\nruleDecimalWithThousandsSeparator :: Rule\nruleDecimalWithThousandsSeparator = Rule\n { name = \"decimal with thousands separator\"\n , pattern =\n [ regex \"(\\\\d+(,\\\\d\\\\d\\\\d)+\\\\.\\\\d+)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n parseDouble (Text.replace \",\" Text.empty match) >>= double\n _ -> Nothing\n }\n\nruleDecimalNumeral :: Rule\nruleDecimalNumeral = Rule\n { name = \"decimal number\"\n , pattern =\n [ regex \"(\\\\d*\\\\.\\\\d+)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> parseDecimal True match\n _ -> Nothing\n }\n\nruleDag :: Rule\nruleDag = Rule\n { name = \"d\u00c3\u00a9ag\"\n , pattern =\n [ regex \"d(\u00c3\u00a9|e)ag\"\n ]\n , prod = \\_ -> integer 10\n }\n\nruleNumeralsSuffixesKMG :: Rule\nruleNumeralsSuffixesKMG = Rule\n { name = \"numbers suffixes (K, M, G)\"\n , pattern =\n [ dimension Numeral\n , regex \"([kmg])(?=[\\\\W\\\\$\u00e2\u201a\u00ac]|$)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v}:\n Token RegexMatch (GroupMatch (match:_)):\n _) -> case Text.toLower match of\n \"k\" -> double $ v * 1e3\n \"m\" -> double $ v * 1e6\n \"g\" -> double $ v * 1e9\n _ -> Nothing\n _ -> Nothing\n }\n\noldVigNumeralsSMap :: HashMap Text Integer\noldVigNumeralsSMap = HashMap.fromList\n [ (\"d\u00c3\u00a1 fhichead\", 40)\n , (\"da fhichead\", 40)\n , (\"dh\u00c3\u00a1 fhichead\", 40)\n , (\"dha fhichead\", 40)\n , (\"tr\u00c3\u00ad fichid\", 60)\n , (\"tri fichid\", 60)\n , (\"ceithre fichid\", 80)\n ]\n\nruleOldVigesimalNumeralsS :: Rule\nruleOldVigesimalNumeralsS = Rule\n { name = \"old vigesimal numbers, 20s\"\n , pattern =\n [ regex \"(d[\u00c3\u00a9e]ag )?is (dh?(\u00c3\u00a1|a) fhichead|tr(\u00c3\u00ad|i) fichid|ceithre fichid)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (ten:match:_)):_) -> do\n x <- HashMap.lookup (Text.toLower match) oldVigNumeralsSMap\n integer $ if Text.null ten then x else x + 10\n _ -> Nothing\n }\n\nruleOldVigesimalFiche :: Rule\nruleOldVigesimalFiche = Rule\n { name = \"old vigesimal 20 + 10\"\n , pattern =\n [ regex \"d[\u00c3\u00a9e]ag is fiche\"\n ]\n , prod = const $ integer 30\n }\n\nruleAmhin :: Rule\nruleAmhin = Rule\n { name = \"amh\u00c3\u00a1in\"\n , pattern =\n [ regex \"amh(\u00c3\u00a1|a)in\"\n ]\n , prod = \\_ -> integer 1\n }\n\ntwentyToNinetyMap :: HashMap Text Integer\ntwentyToNinetyMap = HashMap.fromList\n [ (\"fiche\", 20)\n , (\"triocha\", 30)\n , (\"tr\u00c3\u00adocha\", 30)\n , (\"daichead\", 40)\n , (\"caoga\", 50)\n , (\"seasca\", 60)\n , (\"seachto\", 70)\n , (\"seacht\u00c3\u00b3\", 70)\n , (\"ochto\", 80)\n , (\"ocht\u00c3\u00b3\", 80)\n , (\"n\u00c3\u00b3cha\", 90)\n , (\"nocha\", 90)\n ]\n\nruleNumerals :: Rule\nruleNumerals = Rule\n { name = \"numbers, 20-90\"\n , pattern =\n [ regex \"(fiche|tr(\u00c3\u00ad|i)ocha|daichead|caoga|seasca|seacht(\u00c3\u00b3|o)|ocht(\u00c3\u00b3|o)|n(\u00c3\u00b3|o)cha)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) twentyToNinetyMap >>= integer\n _ -> Nothing\n }\n\nruleIntegerWithThousandsSeparator :: Rule\nruleIntegerWithThousandsSeparator = Rule\n { name = \"integer with thousands separator ,\"\n , pattern =\n [ regex \"(\\\\d{1,3}(,\\\\d\\\\d\\\\d){1,5})\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n parseDouble (Text.replace \",\" Text.empty match) >>= double\n _ -> Nothing\n }\n\ncountNumeralsMap :: HashMap Text Integer\ncountNumeralsMap = HashMap.fromList\n [ (\"naid\", 0)\n , (\"n\u00c3\u00a1id\", 0)\n , (\"haon\", 1)\n , (\"d\u00c3\u00b3\", 2)\n , (\"do\", 2)\n , (\"tr\u00c3\u00ad\", 3)\n , (\"tri\", 3)\n , (\"ceathair\", 4)\n , (\"cuig\", 5)\n , (\"c\u00c3\u00baig\", 5)\n , (\"s\u00c3\u00a9\", 6)\n , (\"se\", 6)\n , (\"seacht\", 7)\n , (\"hocht\", 8)\n , (\"naoi\", 9)\n , (\"deich\", 10)\n ]\n\nruleCountNumerals :: Rule\nruleCountNumerals = Rule\n { name = \"count numbers\"\n , pattern =\n [ regex \"a (n(\u00c3\u00a1|a)id|haon|d(\u00c3\u00b3|o)|tr(\u00c3\u00ad|i)|ceathair|c(\u00c3\u00ba|u)ig|s(\u00c3\u00a9|e)|seacht|hocht|naoi|deich)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) countNumeralsMap >>= integer\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleAmhin\n , ruleCountNumerals\n , ruleDag\n , ruleDecimalNumeral\n , ruleDecimalWithThousandsSeparator\n , ruleIntegerWithThousandsSeparator\n , ruleNumerals\n , ruleNumerals2\n , ruleNumeralsPrefixWithNegativeOrMinus\n , ruleNumeralsSuffixesKMG\n , ruleOldVigesimalNumeralsS\n , ruleOldVigesimalFiche\n ]\n", "num_lines": 253} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Numeral.HU.Corpus\n ( corpus ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Locale\nimport Duckling.Numeral.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale HU Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (NumeralValue 0)\n [ \"0\"\n , \"nulla\"\n , \"z\u00c3\u00a9r\u00c3\u00b3\"\n ]\n , examples (NumeralValue 1)\n [ \"1\"\n , \"egy\"\n ]\n , examples (NumeralValue 2)\n [ \"kett\u00c5\u2018\"\n ]\n , examples (NumeralValue 3)\n [ \"h\u00c3\u00a1rom\"\n ]\n , examples (NumeralValue 4)\n [ \"n\u00c3\u00a9gy\"\n ]\n , examples (NumeralValue 5)\n [ \"\u00c3\u00b6t\"\n ]\n , examples (NumeralValue 6)\n [ \"hat\"\n ]\n , examples (NumeralValue 7)\n [ \"h\u00c3\u00a9t\"\n ]\n , examples (NumeralValue 8)\n [ \"nyolc\"\n ]\n , examples (NumeralValue 9)\n [ \"kilenc\"\n ]\n , examples (NumeralValue 11)\n [ \"tizenegy\"\n ]\n , examples (NumeralValue 15)\n [ \"tizen\u00c3\u00b6t\"\n ]\n , examples (NumeralValue 17)\n [ \"tizenh\u00c3\u00a9t\"\n ]\n , examples (NumeralValue 20)\n [ \"20\"\n , \"h\u00c3\u00basz\"\n ]\n , examples (NumeralValue 22)\n [ \"huszonkett\u00c5\u2018\"\n ]\n , examples (NumeralValue 24)\n [ \"24\"\n , \"huszonn\u00c3\u00a9gy\"\n ]\n , examples (NumeralValue 26)\n [ \"huszonhat\"\n ]\n , examples (NumeralValue 28)\n [ \"huszonnyolc\"\n ]\n , examples (NumeralValue 10)\n [ \"t\u00c3\u00adz\"\n ]\n , examples (NumeralValue 20)\n [ \"h\u00c3\u00basz\"\n ]\n , examples (NumeralValue 50)\n [ \"\u00c3\u00b6tven\"\n ]\n , examples (NumeralValue 34)\n [ \"harmincn\u00c3\u00a9gy\"\n ]\n ]\n", "num_lines": 98} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n{-# LANGUAGE NoRebindableSyntax #-}\n\nmodule Duckling.Numeral.HU.Rules\n ( rules\n ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport Data.Maybe\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers\nimport Duckling.Numeral.Types (NumeralData (..))\nimport Duckling.Regex.Types\nimport Duckling.Types\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleNumeralMap :: HashMap Text Integer\nruleNumeralMap = HashMap.fromList\n [ ( \"nulla\", 0 )\n , ( \"z\\x00E9r\\x00F3\", 0 )\n , ( \"egy\", 1 )\n , ( \"kett\\x0151\", 2 )\n , ( \"h\\x00E1rom\", 3 )\n , ( \"n\\x00E9gy\", 4 )\n , ( \"\\x00F6t\", 5)\n , ( \"hat\", 6)\n , ( \"h\\x00E9t\", 7)\n , ( \"nyolc\", 8)\n , ( \"kilenc\", 9)\n , ( \"t\\x00EDz\", 10)\n ]\n\nruleNumeral :: Rule\nruleNumeral = Rule\n { name = \"number (0..10)\"\n , pattern =\n [ regex \"(nulla|z\\x00E9r\\x00F3|egy|kett\\x0151|h\\x00E1rom|n\\x00E9gy|\\x00F6t|hat|h\\x00E9t|nyolc|kilenc|t\\x00EDz)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) ruleNumeralMap >>= integer\n _ -> Nothing\n }\n\nelevenToNineteenMap :: HashMap Text Integer\nelevenToNineteenMap = HashMap.fromList\n [ ( \"tizenegy\", 11 )\n , ( \"tizenkett\\x0151\", 12 )\n , ( \"tizenh\\x00E1rom\", 13 )\n , ( \"tizenn\\x00E9gy\", 14 )\n , ( \"tizen\\x00F6t\", 15 )\n , ( \"tizenhat\", 16 )\n , ( \"tizenh\\x00E9t\", 17 )\n , ( \"tizennyolc\", 18 )\n , ( \"tizenkilenc\", 19 )\n ]\n\nruleElevenToNineteen :: Rule\nruleElevenToNineteen = Rule\n { name = \"number (11..19)\"\n , pattern =\n [ regex \"(tizenegy|tizenkett\\x0151|tizenh\\x00E1rom|tizenn\\x00E9gy|tizen\\x00F6t|tizenhat|tizenh\\x00E9t|tizennyolc|tizenkilenc)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) elevenToNineteenMap >>= integer\n _ -> Nothing\n }\n\ntwentyoneToTwentynineMap :: HashMap Text Integer\ntwentyoneToTwentynineMap = HashMap.fromList\n [ ( \"huszonegy\", 21 )\n , ( \"huszonkett\\x0151\", 22 )\n , ( \"huszonh\\x00E1rom\", 23 )\n , ( \"huszonn\\x00E9gy\", 24 )\n , ( \"huszon\\x00F6t\", 25 )\n , ( \"huszonhat\", 26 )\n , ( \"huszonh\\x00E9t\", 27 )\n , ( \"huszonnyolc\", 28 )\n , ( \"huszonkilenc\", 29 )\n ]\n\nruleTwentyoneToTwentynine :: Rule\nruleTwentyoneToTwentynine = Rule\n { name = \"number (21..29)\"\n , pattern =\n [ regex \"(huszonegy|huszonkett\\x0151|huszonh\\x00E1rom|huszonn\\x00E9gy|huszon\\x00F6t|huszonhat|huszonh\\x00E9t|huszonnyolc|huszonkilenc)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) twentyoneToTwentynineMap >>= integer\n _ -> Nothing\n }\n\ntensMap :: HashMap Text Integer\ntensMap = HashMap.fromList\n [ ( \"h\\x00FAsz\", 20 )\n , ( \"harminc\", 30 )\n , ( \"negyven\", 40 )\n , ( \"\\x00F6tven\", 50 )\n , ( \"hatvan\", 60 )\n , ( \"hetven\", 70 )\n , ( \"nyolcvan\", 80 )\n , ( \"kilencven\", 90 )\n ]\n\nruleTens :: Rule\nruleTens = Rule\n { name = \"integer (20,30..90)\"\n , pattern =\n [ regex \"(h\\x00FAsz|harminc|negyven|\u00c3\u00b6tven|hatvan|hetven|nyolcvan|kilencven)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) tensMap >>= integer\n _ -> Nothing\n }\n\nruleCompositeTens :: Rule\nruleCompositeTens = Rule\n { name = \"integer ([3-9][1-9])\"\n , pattern =\n [ regex \"(harminc|negyven|\\x00F6tven|hatvan|hetven|nyolcvan|kilencven)(egy|kett\\x0151|h\\x00E1rom|n\\x00E9gy|\\x00F6t|hat|h\\x00E9t|nyolc|kilenc)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (m1:m2:_)):_) -> do\n v1 <- HashMap.lookup (Text.toLower m1) tensMap\n v2 <- HashMap.lookup (Text.toLower m2) ruleNumeralMap\n integer $ v1 + v2\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleNumeral\n , ruleElevenToNineteen\n , ruleTwentyoneToTwentynine\n , ruleTens\n , ruleCompositeTens\n ]\n", "num_lines": 155} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Numeral.ID.Corpus\n ( corpus ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Locale\nimport Duckling.Numeral.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale ID Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (NumeralValue 0)\n [ \"0\"\n , \"nol\"\n , \"kosong\"\n ]\n , examples (NumeralValue 1)\n [ \"1\"\n , \"satu\"\n ]\n , examples (NumeralValue 2)\n [ \"2\"\n , \"Dua\"\n ]\n , examples (NumeralValue 10)\n [ \"10\"\n , \"sepuluh\"\n ]\n , examples (NumeralValue 33)\n [ \"33\"\n , \"tiga puluh tiga\"\n , \"0033\"\n ]\n , examples (NumeralValue 100)\n [ \"100\"\n , \"seratus\"\n ]\n , examples (NumeralValue 17)\n [ \"17\"\n , \"tujuh belas\"\n ]\n , examples (NumeralValue 28)\n [ \"28\"\n , \"dua puluh delapan\"\n ]\n , examples (NumeralValue 1.1)\n [ \"1,1\"\n , \"1,10\"\n , \"01,10\"\n ]\n , examples (NumeralValue 0.77)\n [ \"0,77\"\n , \",77\"\n ]\n , examples (NumeralValue 100000)\n [ \"100.000\"\n , \"100000\"\n , \"100K\"\n , \"100k\"\n ]\n , examples (NumeralValue 3000000)\n [ \"3M\"\n , \"3000K\"\n , \"3000000\"\n , \"3.000.000\"\n ]\n , examples (NumeralValue 1200000)\n [ \"1.200.000\"\n , \"1200000\"\n , \"1,2M\"\n , \"1200K\"\n , \",0012G\"\n ]\n , examples (NumeralValue (-1200000))\n [ \"- 1.200.000\"\n , \"-1200000\"\n , \"minus 1.200.000\"\n , \"negatif 1200000\"\n , \"-1,2M\"\n , \"-1200K\"\n , \"-,0012G\"\n , \"-0,0012G\"\n ]\n , examples (NumeralValue 5000)\n [ \"5 ribu\"\n , \"lima ribu\"\n ]\n , examples (NumeralValue 122)\n [ \"seratus dua puluh dua\"\n ]\n , examples (NumeralValue 200000)\n [ \"dua ratus ribu\"\n ]\n , examples (NumeralValue 10011)\n [ \"sepuluh ribu sebelas\"\n ]\n , examples (NumeralValue 721012)\n [ \"tujuh ratus dua puluh satu ribu dua belas\"\n ]\n , examples (NumeralValue 31256721)\n [ \"tiga puluh satu juta dua ratus lima puluh enam ribu tujuh ratus dua puluh satu\"\n ]\n ]\n", "num_lines": 118} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Numeral.ID.Rules\n ( rules\n ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport Data.Maybe\nimport Data.Text (Text)\nimport Prelude\nimport Data.String\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers\nimport Duckling.Numeral.Types (NumeralData (..))\nimport Duckling.Regex.Types\nimport Duckling.Types\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleIntegerMap :: HashMap Text Integer\nruleIntegerMap = HashMap.fromList\n [ ( \"kosong\" , 0 )\n , ( \"nol\" , 0 )\n , ( \"satu\" , 1 )\n , ( \"dua\" , 2 )\n , ( \"tiga\" , 3 )\n , ( \"empat\" , 4 )\n , ( \"lima\" , 5 )\n , ( \"enam\" , 6 )\n , ( \"tujuh\" , 7 )\n , ( \"delapan\" , 8 )\n , ( \"sembilan\", 9 )\n , ( \"sebelas\" , 11 )\n ]\n\nruleTeen :: Rule\nruleTeen = Rule\n { name = \"teen\"\n , pattern =\n [ Predicate $ numberBetween 2 10\n , regex \"belas\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v}:_) -> double $ v + 10\n _ -> Nothing\n }\n\nruleNumeralCommaNumeral :: Rule\nruleNumeralCommaNumeral = Rule\n { name = \"number comma number\"\n , pattern =\n [ dimension Numeral\n , regex \"koma\"\n , Predicate $ not . hasGrain\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral nd1:_:Token Numeral nd2:_) ->\n double $ TNumeral.value nd1 + decimalsToDouble (TNumeral.value nd2)\n _ -> Nothing\n }\n\nruleNumeralsPrefixWithNegativeOrMinus :: Rule\nruleNumeralsPrefixWithNegativeOrMinus = Rule\n { name = \"numbers prefix with -, negative or minus\"\n , pattern =\n [ regex \"-|minus|negatif\"\n , Predicate isPositive\n ]\n , prod = \\tokens -> case tokens of\n (_:Token Numeral nd:_) -> double (TNumeral.value nd * (-1))\n _ -> Nothing\n }\n\nruleTen :: Rule\nruleTen = Rule\n { name = \"ten\"\n , pattern =\n [ regex \"(se)?puluh\"\n ]\n , prod = \\_ -> integer 10 >>= withGrain 1\n }\n\nruleDecimalWithThousandsSeparator :: Rule\nruleDecimalWithThousandsSeparator = Rule\n { name = \"decimal with thousands separator\"\n , pattern =\n [ regex \"(\\\\d+(\\\\.\\\\d\\\\d\\\\d)+,\\\\d+)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):\n _) -> let fmt = Text.replace \",\" \".\" $ Text.replace \".\" Text.empty match\n in parseDouble fmt >>= double\n _ -> Nothing\n }\n\nruleMultiply :: Rule\nruleMultiply = Rule\n { name = \"compose by multiplication\"\n , pattern =\n [ dimension Numeral\n , Predicate isMultipliable\n ]\n , prod = \\tokens -> case tokens of\n (token1:token2:_) -> multiply token1 token2\n _ -> Nothing\n }\n\n\nruleDecimalNumeral :: Rule\nruleDecimalNumeral = Rule\n { name = \"decimal number\"\n , pattern =\n [ regex \"(\\\\d*,\\\\d+)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> parseDecimal False match\n _ -> Nothing\n }\n\nruleInteger3 :: Rule\nruleInteger3 = Rule\n { name = \"integer 21..99\"\n , pattern =\n [ oneOf [70, 20, 60, 50, 40, 90, 30, 80]\n , Predicate $ numberBetween 1 10\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v1}:\n Token Numeral NumeralData{TNumeral.value = v2}:\n _) -> double $ v1 + v2\n _ -> Nothing\n }\n\nruleIntersect :: Rule\nruleIntersect = Rule\n { name = \"intersect\"\n , pattern =\n [ Predicate hasGrain\n , Predicate $ and . sequence [not . isMultipliable, isPositive]\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = val1, TNumeral.grain = Just g}:\n Token Numeral NumeralData{TNumeral.value = val2}:\n _) | (10 ** fromIntegral g) > val2 -> double $ val1 + val2\n _ -> Nothing\n }\n\nruleSomefewcouple :: Rule\nruleSomefewcouple = Rule\n { name = \"some/few/couple\"\n , pattern =\n [ regex \"beberapa\"\n ]\n , prod = \\_ -> integer 3\n }\n\nruleNumeralsSuffixesKMG :: Rule\nruleNumeralsSuffixesKMG = Rule\n { name = \"numbers suffixes (K, M, G)\"\n , pattern =\n [ dimension Numeral\n , regex \"([kmg])(?=[\\\\W\\\\$\u00e2\u201a\u00ac]|$)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v}:\n Token RegexMatch (GroupMatch (match:_)):\n _) -> case Text.toLower match of\n \"k\" -> double $ v * 1e3\n \"m\" -> double $ v * 1e6\n \"g\" -> double $ v * 1e9\n _ -> Nothing\n _ -> Nothing\n }\n\nrulePowersOfTen :: Rule\nrulePowersOfTen = Rule\n { name = \"powers of tens\"\n , pattern =\n [ regex \"(se)?(ratus|ribu|juta)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (_:match:_)):_) -> case Text.toLower match of\n \"ratus\"-> double 1e2 >>= withGrain 2 >>= withMultipliable\n \"ribu\" -> double 1e3 >>= withGrain 3 >>= withMultipliable\n \"juta\" -> double 1e6 >>= withGrain 6 >>= withMultipliable\n _ -> Nothing\n _ -> Nothing\n }\n\nruleDozen :: Rule\nruleDozen = Rule\n { name = \"dozen\"\n , pattern =\n [ regex \"(se)?lusin\"\n ]\n , prod = \\_ -> integer 12 >>= withGrain 1 >>= withMultipliable\n }\n\nruleInteger :: Rule\nruleInteger = Rule\n { name = \"integer (0..9 11)\"\n , pattern =\n [ regex \"(kosong|nol|satu|dua|tiga|empat|lima|enam|tujuh|delapan|sembilan|sebelas)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) ruleIntegerMap >>= integer\n _ -> Nothing\n }\n\nruleInteger2 :: Rule\nruleInteger2 = Rule\n { name = \"integer 20..90\"\n , pattern =\n [ Predicate $ numberBetween 2 10\n , numberWith TNumeral.value (== 10)\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v1}:\n Token Numeral NumeralData{TNumeral.value = v2, TNumeral.grain = Just g}:\n _) -> double (v1 * v2) >>= withGrain g\n _ -> Nothing\n }\n\nruleIntegerWithThousandsSeparator :: Rule\nruleIntegerWithThousandsSeparator = Rule\n { name = \"integer with thousands separator .\"\n , pattern =\n [ regex \"(\\\\d{1,3}(\\\\.\\\\d\\\\d\\\\d){1,5})\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n parseDouble (Text.replace \".\" Text.empty match) >>= double\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleDecimalNumeral\n , ruleDecimalWithThousandsSeparator\n , ruleDozen\n , ruleInteger\n , ruleInteger2\n , ruleInteger3\n , ruleIntegerWithThousandsSeparator\n , ruleIntersect\n , ruleMultiply\n , ruleNumeralCommaNumeral\n , ruleNumeralsPrefixWithNegativeOrMinus\n , ruleNumeralsSuffixesKMG\n , rulePowersOfTen\n , ruleSomefewcouple\n , ruleTeen\n , ruleTen\n ]\n", "num_lines": 266} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Numeral.IS.Corpus\n ( corpus\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Locale\nimport Duckling.Numeral.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncontext :: Context\ncontext = testContext{locale = makeLocale IS Nothing}\n\ncorpus :: Corpus\ncorpus = (context, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (NumeralValue 0)\n [ \"0\"\n , \"n\u00c3\u00ball\"\n , \"null\"\n ]\n , examples (NumeralValue 1)\n [ \"1\"\n , \"einn\"\n ]\n , examples (NumeralValue 2)\n [ \"tveir\"\n ]\n , examples (NumeralValue 3)\n [ \"\u00c3\u00ber\u00c3\u00adr\"\n ]\n , examples (NumeralValue 4)\n [ \"fj\u00c3\u00b3rir\"\n ]\n , examples (NumeralValue 5)\n [ \"fimm\"\n ]\n , examples (NumeralValue 6)\n [ \"sex\"\n ]\n , examples (NumeralValue 7)\n [ \"sj\u00c3\u00b6\"\n ]\n , examples (NumeralValue 8)\n [ \"\u00c3\u00a1tta\"\n ]\n , examples (NumeralValue 9)\n [ \"n\u00c3\u00adu\"\n ]\n , examples (NumeralValue 10)\n [ \"t\u00c3\u00adu\"\n ]\n , examples (NumeralValue 11)\n [ \"ellefu\"\n ]\n , examples (NumeralValue 15)\n [ \"fimmt\u00c3\u00a1n\"\n ]\n , examples (NumeralValue 17)\n [ \"sautj\u00c3\u00a1n\"\n ]\n , examples (NumeralValue 20)\n [ \"20\"\n , \"tuttugu\"\n ]\n ]\n", "num_lines": 80} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE NoRebindableSyntax #-}\n\nmodule Duckling.Numeral.IS.Rules\n ( rules\n ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport Data.Maybe\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers\nimport Duckling.Numeral.Types (NumeralData (..))\nimport Duckling.Regex.Types\nimport Duckling.Types\nimport qualified Duckling.Numeral.Types as TNumeral\n\nzeroToTwentyMap:: HashMap Text Integer\nzeroToTwentyMap = HashMap.fromList\n [ ( \"n\u00c3\u00ball\", 0 )\n , ( \"null\", 0 )\n , ( \"einn\", 1 )\n , ( \"tveir\", 2 )\n , ( \"\u00c3\u00ber\u00c3\u00adr\", 3 )\n , ( \"fj\u00c3\u00b3rir\", 4 )\n , ( \"fimm\", 5 )\n , ( \"sex\", 6 )\n , ( \"sj\u00c3\u00b6\", 7 )\n , ( \"\u00c3\u00a1tta\", 8 )\n , ( \"n\u00c3\u00adu\", 9 )\n , ( \"t\u00c3\u00adu\", 10 )\n , ( \"ellefu\", 11 )\n , ( \"t\u00c3\u00b3lf\", 12 )\n , ( \"\u00c3\u00berett\u00c3\u00a1n\", 13 )\n , ( \"fj\u00c3\u00b3rt\u00c3\u00a1n\", 14 )\n , ( \"fimmt\u00c3\u00a1n\", 15 )\n , ( \"sext\u00c3\u00a1n\", 16 )\n , ( \"sautj\u00c3\u00a1n\", 17 )\n , ( \"\u00c3\u00a1tj\u00c3\u00a1n\", 18 )\n , ( \"n\u00c3\u00adtj\u00c3\u00a1n\", 19 )\n , ( \"tuttugu\", 20 )\n ]\n\nruleZeroToTwenty :: Rule\nruleZeroToTwenty = Rule\n { name = \"number (0..20)\"\n , pattern =\n [ regex \"(n[\u00c3\u00bau]ll|einn|tveir|\u00c3\u00ber\u00c3\u00adr|fj\u00c3\u00b3rir|fimm(t\u00c3\u00a1n)?|sex(t\u00c3\u00a1n)?|sj\u00c3\u00b6|\u00c3\u00a1tta|n\u00c3\u00adu|t\u00c3\u00adu|ellefu|t\u00c3\u00b3lf|\u00c3\u00berett\u00c3\u00a1n|fj\u00c3\u00b3rt\u00c3\u00a1n|sautj\u00c3\u00a1n|\u00c3\u00a1tj\u00c3\u00a1n|n\u00c3\u00adtj\u00c3\u00a1n|tuttugu)\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) zeroToTwentyMap >>= integer\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleZeroToTwenty\n ]\n", "num_lines": 74} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Numeral.IT.Corpus\n ( corpus ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Locale\nimport Duckling.Numeral.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale IT Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (NumeralValue 0)\n [ \"0\"\n , \"nulla\"\n , \"zero\"\n ]\n , examples (NumeralValue 1)\n [ \"1\"\n , \"uno\"\n , \"Un\"\n ]\n , examples (NumeralValue 2)\n [ \"2\"\n , \"due\"\n ]\n , examples (NumeralValue 3)\n [ \"3\"\n , \"tre\"\n ]\n , examples (NumeralValue 4)\n [ \"4\"\n , \"quattro\"\n ]\n , examples (NumeralValue 5)\n [ \"5\"\n , \"cinque\"\n ]\n , examples (NumeralValue 6)\n [ \"6\"\n , \"sei\"\n ]\n , examples (NumeralValue 7)\n [ \"7\"\n , \"sette\"\n ]\n , examples (NumeralValue 8)\n [ \"8\"\n , \"otto\"\n ]\n , examples (NumeralValue 9)\n [ \"9\"\n , \"nove\"\n ]\n , examples (NumeralValue 10)\n [ \"10\"\n , \"dieci\"\n ]\n , examples (NumeralValue 33)\n [ \"33\"\n , \"trentatr\u00c3\u00a9\"\n , \"0033\"\n ]\n , examples (NumeralValue 11)\n [ \"11\"\n , \"Undici\"\n ]\n , examples (NumeralValue 12)\n [ \"12\"\n , \"dodici\"\n ]\n , examples (NumeralValue 13)\n [ \"13\"\n , \"tredici\"\n ]\n , examples (NumeralValue 14)\n [ \"14\"\n , \"quattordici\"\n ]\n , examples (NumeralValue 15)\n [ \"15\"\n , \"quindici\"\n ]\n , examples (NumeralValue 16)\n [ \"16\"\n , \"sedici\"\n ]\n , examples (NumeralValue 17)\n [ \"17\"\n , \"diciassette\"\n ]\n , examples (NumeralValue 18)\n [ \"18\"\n , \"diciotto\"\n ]\n , examples (NumeralValue 19)\n [ \"19\"\n , \"diciannove\"\n ]\n , examples (NumeralValue 20)\n [ \"20\"\n , \"venti\"\n ]\n , examples (NumeralValue 1.1)\n [ \"1,1\"\n , \"1,10\"\n , \"01,10\"\n ]\n , examples (NumeralValue 0.77)\n [ \"0,77\"\n , \",77\"\n ]\n , examples (NumeralValue 100000)\n [ \"100.000\"\n , \"100000\"\n , \"100K\"\n , \"100k\"\n , \"100 000\"\n ]\n , examples (NumeralValue 3000000)\n [ \"3M\"\n , \"3000K\"\n , \"3000000\"\n , \"3.000.000\"\n , \"3 000 000\"\n ]\n , examples (NumeralValue 1200000)\n [ \"1.200.000\"\n , \"1200000\"\n , \"1,2M\"\n , \"1200K\"\n , \",0012G\"\n ]\n , examples (NumeralValue (-1200000))\n [ \"- 1.200.000\"\n , \"-1200000\"\n , \"meno 1.200.000\"\n , \"negativo 1200000\"\n , \"-1,2M\"\n , \"-1200K\"\n , \"-,0012G\"\n ]\n , examples (NumeralValue 6.7)\n [ \"6,7\"\n ]\n , examples (NumeralValue 6700.54)\n [ \"6.700,54\"\n , \"6 700,54\"\n ]\n ]\n", "num_lines": 164} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Numeral.IT.Rules\n ( rules\n ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers\nimport Duckling.Numeral.Types (NumeralData (..))\nimport Duckling.Regex.Types\nimport Duckling.Types\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleNumeralsPrefixWithNegativeOrMinus :: Rule\nruleNumeralsPrefixWithNegativeOrMinus = Rule\n { name = \"numbers prefix with -, negative or minus\"\n , pattern =\n [ regex \"-|meno|negativo\"\n , Predicate isPositive\n ]\n , prod = \\tokens -> case tokens of\n (_:Token Numeral nd:_) -> double (TNumeral.value nd * (-1))\n _ -> Nothing\n }\n\nruleDecimalWithThousandsSeparator :: Rule\nruleDecimalWithThousandsSeparator = Rule\n { name = \"decimal with thousands separator\"\n , pattern =\n [ regex \"(\\\\d+(([\\\\. ])\\\\d\\\\d\\\\d)+,\\\\d+)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_:sep:_)):\n _) -> let fmt = Text.replace \",\" \".\" $ Text.replace sep Text.empty match\n in parseDouble fmt >>= double\n _ -> Nothing\n }\n\nruleDecimalNumeral :: Rule\nruleDecimalNumeral = Rule\n { name = \"decimal number\"\n , pattern =\n [ regex \"(\\\\d*,\\\\d+)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):\n _) -> parseDecimal False match\n _ -> Nothing\n }\n\ntensMap :: HashMap Text Integer\ntensMap = HashMap.fromList\n [ (\"venti\", 20)\n , (\"trenta\", 30)\n , (\"quaranta\", 40)\n , (\"cinquanta\", 50)\n , (\"sessanta\", 60)\n , (\"settanta\", 70)\n , (\"ottanta\", 80)\n , (\"novanta\", 90)\n ]\n\nruleNumeral2 :: Rule\nruleNumeral2 = Rule\n { name = \"number (20..90)\"\n , pattern =\n [ regex \"(venti|trenta|quaranta|cinquanta|sessanta|settanta|ottanta|novanta)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) tensMap >>= integer\n _ -> Nothing\n }\n\nzeroNineteenMap :: HashMap Text Integer\nzeroNineteenMap = HashMap.fromList\n [ (\"zero\", 0)\n , (\"niente\", 0)\n , (\"nulla\", 0)\n , (\"un\", 1)\n , (\"uno\", 1)\n , (\"due\", 2)\n , (\"tre\", 3)\n , (\"quattro\", 4)\n , (\"cinque\", 5)\n , (\"sei\", 6)\n , (\"sette\", 7)\n , (\"otto\", 8)\n , (\"nove\", 9)\n , (\"dieci\", 10)\n , (\"undici\", 11)\n , (\"dodici\", 12)\n , (\"tredici\", 13)\n , (\"quattordici\", 14)\n , (\"quindici\", 15)\n , (\"sedici\", 16)\n , (\"diciassette\", 17)\n , (\"diciotto\", 18)\n , (\"diciannove\", 19)\n ]\n\nruleNumeral :: Rule\nruleNumeral = Rule\n { name = \"number (0..19)\"\n , pattern =\n [ regex \"(zero|nulla|niente|uno|due|tredici|tre|quattro|cinque|sei|sette|otto|nove|dieci|undici|dodici|quattordici|quindici|sedici|diciassette|diciotto|diciannove|un)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) zeroNineteenMap >>= integer\n _ -> Nothing\n }\n\nhundredsMap :: HashMap Text Integer\nhundredsMap = HashMap.fromList\n [ (\"cento\", 100)\n , (\"duecento\", 200)\n , (\"trecento\", 300)\n , (\"quattrocento\", 400)\n , (\"cinquecento\", 500)\n , (\"seicento\", 600)\n , (\"settecento\", 700)\n , (\"ottocento\", 800)\n , (\"novecento\", 900)\n , (\"mila\", 1000)\n , (\"mille\", 1000)\n ]\n\nruleNumeral5 :: Rule\nruleNumeral5 = Rule\n { name = \"number 100..1000 \"\n , pattern =\n [ regex \"(due|tre|quattro|cinque|sei|sette|otto|nove)?cento|mil(a|le)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) hundredsMap >>= integer\n _ -> Nothing\n }\n\nruleNumeral3 :: Rule\nruleNumeral3 = Rule\n { name = \"number (21..29 31..39 41..49 51..59 61..69 71..79 81..89 91..99)\"\n , pattern =\n [ oneOf [70, 20, 60, 50, 40, 90, 30, 80]\n , regex \"e\"\n , Predicate $ numberBetween 1 10\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v1}:\n _:\n Token Numeral NumeralData{TNumeral.value = v2}:\n _) -> double $ v1 + v2\n _ -> Nothing\n }\n\nruleNumeralsSuffixesKMG :: Rule\nruleNumeralsSuffixesKMG = Rule\n { name = \"numbers suffixes (K, M, G)\"\n , pattern =\n [ dimension Numeral\n , regex \"([kmg])(?=[\\\\W\\\\$\u00e2\u201a\u00ac]|$)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v}:\n Token RegexMatch (GroupMatch (match:_)):\n _) -> case Text.toLower match of\n \"k\" -> double $ v * 1e3\n \"m\" -> double $ v * 1e6\n \"g\" -> double $ v * 1e9\n _ -> Nothing\n _ -> Nothing\n }\n\ntwentyoneNinetynineMap :: HashMap Text Integer\ntwentyoneNinetynineMap = HashMap.fromList\n [ (\"ventuno\", 21)\n , (\"ventidue\", 22)\n , (\"ventitre\", 23)\n , (\"ventitr\u00c3\u00a9\", 23)\n , (\"ventiquattro\", 24)\n , (\"venticinque\", 25)\n , (\"ventisei\", 26)\n , (\"ventisette\", 27)\n , (\"ventotto\", 28)\n , (\"ventinove\", 29)\n , (\"trentuno\", 31)\n , (\"trentadue\", 32)\n , (\"trentatre\", 33)\n , (\"trentatr\u00c3\u00a9\", 33)\n , (\"trentaquattro\", 34)\n , (\"trentacinque\", 35)\n , (\"trentasei\", 36)\n , (\"trentasette\", 37)\n , (\"trentotto\", 38)\n , (\"trentanove\", 39)\n , (\"quarantuno\", 41)\n , (\"quarantadue\", 42)\n , (\"quarantatre\", 43)\n , (\"quarantatr\u00c3\u00a9\", 43)\n , (\"quarantaquattro\", 44)\n , (\"quarantacinque\", 45)\n , (\"quarantasei\", 46)\n , (\"quarantasette\", 47)\n , (\"quarantotto\", 48)\n , (\"quarantanove\", 49)\n , (\"cinquantuno\", 51)\n , (\"cinquantadue\", 52)\n , (\"cinquantatre\", 53)\n , (\"cinquantatr\u00c3\u00a9\", 53)\n , (\"cinquantaquattro\", 54)\n , (\"cinquantacinque\", 55)\n , (\"cinquantasei\", 56)\n , (\"cinquantasette\", 57)\n , (\"cinquantotto\", 58)\n , (\"cinquantanove\", 59)\n , (\"sessantuno\", 61)\n , (\"sessantadue\", 62)\n , (\"sessantatr\u00c3\u00a9\", 63)\n , (\"sessantatre\", 63)\n , (\"sessantaquattro\", 64)\n , (\"sessantacinque\", 65)\n , (\"sessantasei\", 66)\n , (\"sessantasette\", 67)\n , (\"sessantotto\", 68)\n , (\"sessantanove\", 69)\n , (\"settantuno\", 71)\n , (\"settantadue\", 72)\n , (\"settantatr\u00c3\u00a9\", 73)\n , (\"settantatre\", 73)\n , (\"settantaquattro\", 74)\n , (\"settantacinque\", 75)\n , (\"settantasei\", 76)\n , (\"settantasette\", 77)\n , (\"settantotto\", 78)\n , (\"settantanove\", 79)\n , (\"ottantuno\", 81)\n , (\"ottantadue\", 82)\n , (\"ottantatr\u00c3\u00a9\", 83)\n , (\"ottantatre\", 83)\n , (\"ottantaquattro\", 84)\n , (\"ottantacinque\", 85)\n , (\"ottantasei\", 86)\n , (\"ottantasette\", 87)\n , (\"ottantotto\", 88)\n , (\"ottantanove\", 89)\n , (\"novantuno\", 91)\n , (\"novantadue\", 92)\n , (\"novantatre\", 93)\n , (\"novantatr\u00c3\u00a9\", 93)\n , (\"novantaquattro\", 94)\n , (\"novantacinque\", 95)\n , (\"novantasei\", 96)\n , (\"novantasette\", 97)\n , (\"novantotto\", 98)\n , (\"novantanove\", 99)\n ]\n\nruleNumeral4 :: Rule\nruleNumeral4 = Rule\n { name = \"number (21..29 31..39 41..49 51..59 61..69 71..79 81..89 91..99)\"\n , pattern =\n [ regex \"((venti|trenta|quaranta|cinquanta|sessanta|settanta|ottanta|novanta)(due|tre|tr\u00c3\u00a9|quattro|cinque|sei|sette|nove))|((vent|trent|quarant|cinquant|sessant|settant|ottant|novant)(uno|otto))\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) twentyoneNinetynineMap >>= integer\n _ -> Nothing\n }\n\nruleNumerals :: Rule\nruleNumerals = Rule\n { name = \"numbers 200..999\"\n , pattern =\n [ Predicate $ numberBetween 2 10\n , numberWith TNumeral.value (== 100)\n , Predicate $ numberBetween 0 100\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v1}:\n Token Numeral NumeralData{TNumeral.value = v2}:\n Token Numeral NumeralData{TNumeral.value = v3}:\n _) -> double $ v1 * v2 + v3\n _ -> Nothing\n }\n\nruleIntegerWithThousandsSeparator :: Rule\nruleIntegerWithThousandsSeparator = Rule\n { name = \"integer with thousands separator .\"\n , pattern =\n [ regex \"(\\\\d{1,3}(([\\\\. ])\\\\d\\\\d\\\\d){1,5})\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_:sep:_)):\n _) -> let fmt = Text.replace sep Text.empty match\n in parseDouble fmt >>= double\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleDecimalNumeral\n , ruleDecimalWithThousandsSeparator\n , ruleIntegerWithThousandsSeparator\n , ruleNumeral\n , ruleNumeral2\n , ruleNumeral3\n , ruleNumeral4\n , ruleNumeral5\n , ruleNumerals\n , ruleNumeralsPrefixWithNegativeOrMinus\n , ruleNumeralsSuffixesKMG\n ]\n", "num_lines": 329} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Numeral.NB.Corpus\n ( corpus ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Locale\nimport Duckling.Numeral.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale NB Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (NumeralValue 0)\n [ \"0\"\n , \"null\"\n ]\n , examples (NumeralValue 1)\n [ \"1\"\n , \"\u00c3\u00a9n\"\n , \"en\"\n , \"Ett\"\n ]\n , examples (NumeralValue 2)\n [ \"2\"\n , \"to\"\n , \"et par\"\n ]\n , examples (NumeralValue 7)\n [ \"7\"\n , \"syv\"\n , \"sju\"\n ]\n , examples (NumeralValue 14)\n [ \"14\"\n , \"fjorten\"\n ]\n , examples (NumeralValue 16)\n [ \"16\"\n , \"seksten\"\n ]\n , examples (NumeralValue 17)\n [ \"17\"\n , \"sytten\"\n , \"s\u00c3\u00b8tten\"\n ]\n , examples (NumeralValue 18)\n [ \"18\"\n , \"atten\"\n ]\n , examples (NumeralValue 20)\n [ \"20\"\n , \"tyve\"\n , \"Tjue\"\n ]\n , examples (NumeralValue 30)\n [ \"30\"\n , \"tretti\"\n , \"tredve\"\n ]\n , examples (NumeralValue 70)\n [ \"70\"\n , \"s\u00c3\u00b8tti\"\n , \"sytti\"\n ]\n , examples (NumeralValue 1.1)\n [ \"1,1\"\n , \"1,10\"\n , \"01,10\"\n ]\n , examples (NumeralValue 0.77)\n [ \"0,77\"\n , \",77\"\n ]\n , examples (NumeralValue 100000)\n [ \"100.000\"\n , \"100000\"\n , \"100K\"\n , \"100k\"\n , \"100 000\"\n ]\n , examples (NumeralValue 3000000)\n [ \"3M\"\n , \"3000K\"\n , \"3000000\"\n , \"3.000.000\"\n , \"3 000 000\"\n ]\n , examples (NumeralValue 1200000)\n [ \"1.200.000\"\n , \"1200000\"\n , \"1,2M\"\n , \"1200K\"\n , \",0012G\"\n , \"1 200 000\"\n ]\n , examples (NumeralValue (-1200000))\n [ \"- 1.200.000\"\n , \"-1200000\"\n , \"minus 1.200.000\"\n , \"negativ 1200000\"\n , \"-1,2M\"\n , \"-1200K\"\n , \"-,0012G\"\n , \"-1 200 000\"\n ]\n , examples (NumeralValue 5000)\n [ \"5 tusen\"\n , \"fem tusen\"\n , \"5 000\"\n ]\n , examples (NumeralValue 100)\n [ \"hundre\"\n ]\n , examples (NumeralValue 5020)\n [ \"fem tusen og tjue\"\n ]\n , examples (NumeralValue 1e9)\n [ \"en milliard\"\n ]\n , examples (NumeralValue 1e12)\n [ \"en billion\"\n ]\n , examples (NumeralValue 1e15)\n [ \"en billiard\"\n ]\n , examples (NumeralValue 1e18)\n [ \"en trillion\"\n ]\n , examples (NumeralValue 1e21)\n [ \"en trilliard\"\n ]\n , examples (NumeralValue 1e24)\n [ \"en kvadrillion\"\n ]\n , examples (NumeralValue 1e27)\n [ \"en kvadrilliard\"\n ]\n , examples (NumeralValue 6e10)\n [ \"seksti milliarder\"\n , \"60 milliarder\"\n ]\n , examples (NumeralValue 3e12)\n [ \"tre billioner\"\n , \"3 billioner\"\n ]\n , examples (NumeralValue 4e17)\n [ \"fire hundre billiarder\"\n , \"400 billiarder\"\n ]\n , examples (NumeralValue 2e18)\n [ \"to trillioner\"\n , \"2 trillioner\"\n ]\n , examples (NumeralValue 1.8e22)\n [ \"atten trilliarder\"\n , \"18 trilliarder\"\n ]\n , examples (NumeralValue 1.8e22)\n [ \"atten trilliarder\"\n , \"18 trilliarder\"\n ]\n , examples (NumeralValue 4.11e26)\n [ \"fire hundre og elleve kvadrillioner\"\n , \"411 kvadrillioner\"\n ]\n , examples (NumeralValue 9e27)\n [ \"ni kvadrilliarder\"\n , \"9 kvadrilliarder\"\n ]\n , examples (NumeralValue 21)\n [ \"tjueen\"\n , \"tjue\u00c3\u00a9n\"\n ]\n , examples (NumeralValue 22)\n [ \"tjueto\"\n ]\n , examples (NumeralValue 23)\n [ \"tjuetre\"\n ]\n , examples (NumeralValue 24)\n [ \"tjuefire\"\n ]\n , examples (NumeralValue 25)\n [ \"tjuefem\"\n ]\n , examples (NumeralValue 26)\n [ \"tjueseks\"\n ]\n , examples (NumeralValue 27)\n [ \"tjuesju\"\n , \"tjuesyv\"\n ]\n , examples (NumeralValue 28)\n [ \"tjue\u00c3\u00a5tte\"\n ]\n , examples (NumeralValue 29)\n [ \"tjueni\"\n ]\n , examples (NumeralValue 31)\n [ \"trettien\"\n , \"tretti\u00c3\u00a9n\"\n ]\n , examples (NumeralValue 32)\n [ \"trettito\"\n ]\n , examples (NumeralValue 33)\n [ \"trettitre\"\n ]\n , examples (NumeralValue 34)\n [ \"trettifire\"\n ]\n , examples (NumeralValue 35)\n [ \"trettifem\"\n ]\n , examples (NumeralValue 36)\n [ \"trettiseks\"\n ]\n , examples (NumeralValue 37)\n [ \"trettisju\"\n , \"trettisyv\"\n ]\n , examples (NumeralValue 38)\n [ \"tretti\u00c3\u00a5tte\"\n ]\n , examples (NumeralValue 39)\n [ \"trettini\"\n ]\n , examples (NumeralValue 41)\n [ \"f\u00c3\u00b8rtien\"\n , \"f\u00c3\u00b8rti\u00c3\u00a9n\"\n ]\n , examples (NumeralValue 42)\n [ \"f\u00c3\u00b8rtito\"\n ]\n , examples (NumeralValue 43)\n [ \"f\u00c3\u00b8rtitre\"\n ]\n , examples (NumeralValue 44)\n [ \"f\u00c3\u00b8rtifire\"\n ]\n , examples (NumeralValue 45)\n [ \"f\u00c3\u00b8rtifem\"\n ]\n , examples (NumeralValue 46)\n [ \"f\u00c3\u00b8rtiseks\"\n ]\n , examples (NumeralValue 47)\n [ \"f\u00c3\u00b8rtisju\"\n , \"f\u00c3\u00b8rtisyv\"\n ]\n , examples (NumeralValue 48)\n [ \"f\u00c3\u00b8rti\u00c3\u00a5tte\"\n ]\n , examples (NumeralValue 49)\n [ \"f\u00c3\u00b8rtini\"\n ]\n , examples (NumeralValue 51)\n [ \"femtien\"\n , \"femti\u00c3\u00a9n\"\n ]\n , examples (NumeralValue 52)\n [ \"femtito\"\n ]\n , examples (NumeralValue 53)\n [ \"femtitre\"\n ]\n , examples (NumeralValue 54)\n [ \"femtifire\"\n ]\n , examples (NumeralValue 55)\n [ \"femtifem\"\n ]\n , examples (NumeralValue 56)\n [ \"femtiseks\"\n ]\n , examples (NumeralValue 57)\n [ \"femtisju\"\n , \"femtisyv\"\n ]\n , examples (NumeralValue 58)\n [ \"femti\u00c3\u00a5tte\"\n ]\n , examples (NumeralValue 59)\n [ \"femtini\"\n ]\n , examples (NumeralValue 61)\n [ \"sekstien\"\n , \"seksti\u00c3\u00a9n\"\n ]\n , examples (NumeralValue 62)\n [ \"sekstito\"\n ]\n , examples (NumeralValue 63)\n [ \"sekstitre\"\n ]\n , examples (NumeralValue 64)\n [ \"sekstifire\"\n ]\n , examples (NumeralValue 65)\n [ \"sekstifem\"\n ]\n , examples (NumeralValue 66)\n [ \"sekstiseks\"\n ]\n , examples (NumeralValue 67)\n [ \"sekstisju\"\n , \"sekstisyv\"\n ]\n , examples (NumeralValue 68)\n [ \"seksti\u00c3\u00a5tte\"\n ]\n , examples (NumeralValue 69)\n [ \"sekstini\"\n ]\n , examples (NumeralValue 71)\n [ \"syttien\"\n , \"s\u00c3\u00b8ttien\"\n , \"s\u00c3\u00b8tti\u00c3\u00a9n\"\n , \"s\u00c3\u00b8tti\u00c3\u00a9n\"\n ]\n , examples (NumeralValue 72)\n [ \"syttito\"\n , \"s\u00c3\u00b8ttito\"\n ]\n , examples (NumeralValue 73)\n [ \"syttitre\"\n , \"s\u00c3\u00b8ttitre\"\n ]\n , examples (NumeralValue 74)\n [ \"syttifire\"\n , \"s\u00c3\u00b8ttifire\"\n ]\n , examples (NumeralValue 75)\n [ \"syttifem\"\n , \"s\u00c3\u00b8ttifem\"\n ]\n , examples (NumeralValue 76)\n [ \"syttiseks\"\n , \"s\u00c3\u00b8ttiseks\"\n ]\n , examples (NumeralValue 77)\n [ \"syttisju\"\n , \"syttisju\"\n , \"s\u00c3\u00b8ttisyv\"\n , \"s\u00c3\u00b8ttisyv\"\n ]\n , examples (NumeralValue 78)\n [ \"s\u00c3\u00b8tti\u00c3\u00a5tte\"\n , \"s\u00c3\u00b8tti\u00c3\u00a5tte\"\n ]\n , examples (NumeralValue 79)\n [ \"s\u00c3\u00b8ttini\"\n , \"s\u00c3\u00b8ttini\"\n ]\n , examples (NumeralValue 81)\n [ \"\u00c3\u00a5ttien\"\n , \"\u00c3\u00a5tti\u00c3\u00a9n\"\n ]\n , examples (NumeralValue 82)\n [ \"\u00c3\u00a5ttito\"\n ]\n , examples (NumeralValue 83)\n [ \"\u00c3\u00a5ttitre\"\n ]\n , examples (NumeralValue 84)\n [ \"\u00c3\u00a5ttifire\"\n ]\n , examples (NumeralValue 85)\n [ \"\u00c3\u00a5ttifem\"\n ]\n , examples (NumeralValue 86)\n [ \"\u00c3\u00a5ttiseks\"\n ]\n , examples (NumeralValue 87)\n [ \"\u00c3\u00a5ttisju\"\n , \"\u00c3\u00a5ttisyv\"\n ]\n , examples (NumeralValue 88)\n [ \"\u00c3\u00a5tti\u00c3\u00a5tte\"\n ]\n , examples (NumeralValue 89)\n [ \"\u00c3\u00a5ttini\"\n ]\n , examples (NumeralValue 91)\n [ \"nittien\"\n , \"nitti\u00c3\u00a9n\"\n ]\n , examples (NumeralValue 92)\n [ \"nittito\"\n ]\n , examples (NumeralValue 93)\n [ \"nittitre\"\n ]\n , examples (NumeralValue 94)\n [ \"nittifire\"\n ]\n , examples (NumeralValue 95)\n [ \"nittifem\"\n ]\n , examples (NumeralValue 96)\n [ \"nittiseks\"\n ]\n , examples (NumeralValue 97)\n [ \"nittisju\"\n , \"nittisyv\"\n ]\n , examples (NumeralValue 98)\n [ \"nitti\u00c3\u00a5tte\"\n ]\n , examples (NumeralValue 99)\n [ \"nittini\"\n ]\n ]\n", "num_lines": 427} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Numeral.NB.Rules\n ( rules\n ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport Data.Maybe\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers\nimport Duckling.Numeral.Types (NumeralData (..))\nimport Duckling.Regex.Types\nimport Duckling.Types\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleIntersectWithAnd :: Rule\nruleIntersectWithAnd = Rule\n { name = \"intersect (with and)\"\n , pattern =\n [ Predicate hasGrain\n , regex \"og\"\n , Predicate $ and . sequence [not . isMultipliable, isPositive]\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = val1, TNumeral.grain = Just g}:\n _:\n Token Numeral NumeralData{TNumeral.value = val2}:\n _) | (10 ** fromIntegral g) > val2 -> double $ val1 + val2\n _ -> Nothing\n }\n\nruleNumeralsPrefixWithNegativeOrMinus :: Rule\nruleNumeralsPrefixWithNegativeOrMinus = Rule\n { name = \"numbers prefix with -, negative or minus\"\n , pattern =\n [ regex \"-|minus|negativ\"\n , Predicate isPositive\n ]\n , prod = \\case\n (_:Token Numeral nd:_) -> double (TNumeral.value nd * (-1))\n _ -> Nothing\n }\n\nruleFew :: Rule\nruleFew = Rule\n { name = \"few\"\n , pattern =\n [ regex \"(noen )?f\u00c3\u00a5\"\n ]\n , prod = \\_ -> integer 3\n }\n\nruleDecimalWithThousandsSeparator :: Rule\nruleDecimalWithThousandsSeparator = Rule\n { name = \"decimal with thousands separator\"\n , pattern =\n [ regex \"(\\\\d+(\\\\.\\\\d\\\\d\\\\d)+\\\\,\\\\d+)\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):\n _) -> let fmt = Text.replace \",\" \".\" $ Text.replace \".\" Text.empty match\n in parseDouble fmt >>= double\n _ -> Nothing\n }\n\nruleMultiply :: Rule\nruleMultiply = Rule\n { name = \"compose by multiplication\"\n , pattern =\n [ dimension Numeral\n , Predicate isMultipliable\n ]\n , prod = \\case\n (token1:token2:_) -> multiply token1 token2\n _ -> Nothing\n }\n\nruleDecimalNumeral :: Rule\nruleDecimalNumeral = Rule\n { name = \"decimal number\"\n , pattern =\n [ regex \"(\\\\d*,\\\\d+)\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):\n _) -> parseDecimal False match\n _ -> Nothing\n }\n\nruleInteger3 :: Rule\nruleInteger3 = Rule\n { name = \"integer 21..99\"\n , pattern =\n [ oneOf [70, 20, 60, 50, 40, 90, 30, 80]\n , Predicate $ numberBetween 1 10\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = v1}:\n Token Numeral NumeralData{TNumeral.value = v2}:\n _) -> double $ v1 + v2\n _ -> Nothing\n }\n\nruleSingle :: Rule\nruleSingle = Rule\n { name = \"single\"\n , pattern =\n [ regex \"enkelt\"\n ]\n , prod = \\_ -> integer 1 >>= withGrain 1\n }\n\nruleIntersect :: Rule\nruleIntersect = Rule\n { name = \"intersect\"\n , pattern =\n [ Predicate hasGrain\n , Predicate $ and . sequence [not . isMultipliable, isPositive]\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = val1, TNumeral.grain = Just g}:\n Token Numeral NumeralData{TNumeral.value = val2}:\n _) | (10 ** fromIntegral g) > val2 -> double $ val1 + val2\n _ -> Nothing\n }\n\nruleNumeralsSuffixesKMG :: Rule\nruleNumeralsSuffixesKMG = Rule\n { name = \"numbers suffixes (K, M, G)\"\n , pattern =\n [ dimension Numeral\n , regex \"([kmg])(?=[\\\\W\\\\$\u00e2\u201a\u00ac]|$)\"\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = v}:\n Token RegexMatch (GroupMatch (match:_)):\n _) -> case Text.toLower match of\n \"k\" -> double $ v * 1e3\n \"m\" -> double $ v * 1e6\n \"g\" -> double $ v * 1e9\n _ -> Nothing\n _ -> Nothing\n }\n\nrulePowersOfTen :: Rule\nrulePowersOfTen = Rule\n { name = \"powers of tens\"\n , pattern =\n [ regex \"(hundre(de)?|tusen?|million(er)?|milliard(?:er)?|billion(?:er)?|billiard(?:er)?|trillion(?:er)?|trilliard(?:er)?|kvadrillion(?:er)?|kvadrilliard(?:er)?)\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of\n \"hundre\" -> double 1e2 >>= withGrain 2 >>= withMultipliable\n \"hundrede\" -> double 1e2 >>= withGrain 2 >>= withMultipliable\n \"tuse\" -> double 1e3 >>= withGrain 3 >>= withMultipliable\n \"tusen\" -> double 1e3 >>= withGrain 3 >>= withMultipliable\n \"million\" -> double 1e6 >>= withGrain 6 >>= withMultipliable\n \"millioner\" -> double 1e6 >>= withGrain 6 >>= withMultipliable\n \"milliard\" -> double 1e9 >>= withGrain 9 >>= withMultipliable\n \"milliarder\" -> double 1e9 >>= withGrain 9 >>= withMultipliable\n \"billion\" -> double 1e12 >>= withGrain 12 >>= withMultipliable\n \"billioner\" -> double 1e12 >>= withGrain 12 >>= withMultipliable\n \"billiard\" -> double 1e15 >>= withGrain 15 >>= withMultipliable\n \"billiarder\" -> double 1e15 >>= withGrain 15 >>= withMultipliable\n \"trillion\" -> double 1e18 >>= withGrain 18 >>= withMultipliable\n \"trillioner\" -> double 1e18 >>= withGrain 18 >>= withMultipliable\n \"trilliard\" -> double 1e21 >>= withGrain 21 >>= withMultipliable\n \"trilliarder\" -> double 1e21 >>= withGrain 21 >>= withMultipliable\n \"kvadrillion\" -> double 1e24 >>= withGrain 24 >>= withMultipliable\n \"kvadrillioner\" -> double 1e24 >>= withGrain 24 >>= withMultipliable\n \"kvadrilliard\" -> double 1e27 >>= withGrain 27 >>= withMultipliable\n \"kvadrilliarder\" -> double 1e27 >>= withGrain 27 >>= withMultipliable\n _ -> Nothing\n _ -> Nothing\n }\n\nruleAPair :: Rule\nruleAPair = Rule\n { name = \"a pair\"\n , pattern =\n [ regex \"et par\"\n ]\n , prod = \\_ -> integer 2 >>= withGrain 1\n }\n\nruleDozen :: Rule\nruleDozen = Rule\n { name = \"dozen\"\n , pattern =\n [ regex \"dusin\"\n ]\n , prod = \\_ -> integer 12 >>= withGrain 1 >>= withMultipliable\n }\n\nzeroToNineteenMap :: HashMap Text Integer\nzeroToNineteenMap = HashMap.fromList\n [ ( \"null\" , 0 )\n , ( \"ingen\" , 0 )\n , ( \"intet\" , 0 )\n , ( \"en\" , 1 )\n , ( \"ett\" , 1 )\n , ( \"\u00c3\u00a9n\" , 1 )\n , ( \"to\" , 2 )\n , ( \"tre\" , 3 )\n , ( \"fire\" , 4 )\n , ( \"fem\" , 5 )\n , ( \"seks\" , 6 )\n , ( \"sju\" , 7 )\n , ( \"syv\" , 7 )\n , ( \"\u00c3\u00a5tte\" , 8 )\n , ( \"ni\" , 9 )\n , ( \"ti\" , 10 )\n , ( \"elleve\" , 11 )\n , ( \"tolv\" , 12 )\n , ( \"tretten\" , 13 )\n , ( \"fjorten\" , 14 )\n , ( \"femten\" , 15 )\n , ( \"seksten\" , 16 )\n , ( \"s\u00c3\u00b8tten\" , 17 )\n , ( \"sytten\" , 17 )\n , ( \"atten\" , 18 )\n , ( \"nitten\" , 19 )\n ]\n\nruleInteger :: Rule\nruleInteger = Rule\n { name = \"integer (0..19)\"\n , pattern =\n [ regex \"(intet|ingen|null|en|ett|\u00c3\u00a9n|to|tretten|tre|fire|femten|fem|seksten|seks|syv|sju|\u00c3\u00a5tte|nitten|ni|ti|elleve|tolv|fjorten|sytten|s\u00c3\u00b8tten|atten)\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) zeroToNineteenMap >>= integer\n _ -> Nothing\n }\n\ntwentyToHundredMap :: HashMap Text Integer\ntwentyToHundredMap = HashMap.fromList\n [ (\"tjueen\", 21)\n , (\"tjue\u00c3\u00a9n\", 21)\n , (\"tjueto\", 22)\n , (\"tjuetre\", 23)\n , (\"tjuefire\", 24)\n , (\"tjuefem\", 25)\n , (\"tjueseks\", 26)\n , (\"tjuesju\", 27)\n , (\"tjuesyv\", 27)\n , (\"tjue\u00c3\u00a5tte\", 28)\n , (\"tjueni\", 29)\n , (\"trettien\", 31)\n , (\"tretti\u00c3\u00a9n\", 31)\n , (\"trettito\", 32)\n , (\"trettitre\", 33)\n , (\"trettifire\", 34)\n , (\"trettifem\", 35)\n , (\"trettiseks\", 36)\n , (\"trettisju\", 37)\n , (\"trettisyv\", 37)\n , (\"tretti\u00c3\u00a5tte\", 38)\n , (\"trettini\", 39)\n , (\"f\u00c3\u00b8rtien\", 41)\n , (\"f\u00c3\u00b8rti\u00c3\u00a9n\", 41)\n , (\"f\u00c3\u00b8rtito\", 42)\n , (\"f\u00c3\u00b8rtitre\", 43)\n , (\"f\u00c3\u00b8rtifire\", 44)\n , (\"f\u00c3\u00b8rtifem\", 45)\n , (\"f\u00c3\u00b8rtiseks\", 46)\n , (\"f\u00c3\u00b8rtisju\", 47)\n , (\"f\u00c3\u00b8rtisyv\", 47)\n , (\"f\u00c3\u00b8rti\u00c3\u00a5tte\", 48)\n , (\"f\u00c3\u00b8rtini\", 49)\n , (\"femtien\", 51)\n , (\"femti\u00c3\u00a9n\", 51)\n , (\"femtito\", 52)\n , (\"femtitre\", 53)\n , (\"femtifire\", 54)\n , (\"femtifem\", 55)\n , (\"femtiseks\", 56)\n , (\"femtisju\", 57)\n , (\"femtisyv\", 57)\n , (\"femti\u00c3\u00a5tte\", 58)\n , (\"femtini\", 59)\n , (\"sekstien\", 61)\n , (\"seksti\u00c3\u00a9n\", 61)\n , (\"sekstito\", 62)\n , (\"sekstitre\", 63)\n , (\"sekstifire\", 64)\n , (\"sekstifem\", 65)\n , (\"sekstiseks\", 66)\n , (\"sekstisju\", 67)\n , (\"sekstisyv\", 67)\n , (\"seksti\u00c3\u00a5tte\", 68)\n , (\"sekstini\", 69)\n , (\"syttien\", 71)\n , (\"sytti\u00c3\u00a9n\", 71)\n , (\"syttito\", 72)\n , (\"syttitre\", 73)\n , (\"syttifire\", 74)\n , (\"syttifem\", 75)\n , (\"syttiseks\", 76)\n , (\"syttisju\", 77)\n , (\"syttisyv\", 77)\n , (\"sytti\u00c3\u00a5tte\", 78)\n , (\"syttini\", 79)\n , (\"s\u00c3\u00b8ttien\", 71)\n , (\"s\u00c3\u00b8tti\u00c3\u00a9n\", 71)\n , (\"s\u00c3\u00b8ttito\", 72)\n , (\"s\u00c3\u00b8ttitre\", 73)\n , (\"s\u00c3\u00b8ttifire\", 74)\n , (\"s\u00c3\u00b8ttifem\", 75)\n , (\"s\u00c3\u00b8ttiseks\", 76)\n , (\"s\u00c3\u00b8ttisju\", 77)\n , (\"s\u00c3\u00b8ttisyv\", 77)\n , (\"s\u00c3\u00b8tti\u00c3\u00a5tte\", 78)\n , (\"s\u00c3\u00b8ttini\", 79)\n , (\"\u00c3\u00a5ttien\", 81)\n , (\"\u00c3\u00a5tti\u00c3\u00a9n\", 81)\n , (\"\u00c3\u00a5ttito\", 82)\n , (\"\u00c3\u00a5ttitre\", 83)\n , (\"\u00c3\u00a5ttifire\", 84)\n , (\"\u00c3\u00a5ttifem\", 85)\n , (\"\u00c3\u00a5ttiseks\", 86)\n , (\"\u00c3\u00a5ttisju\", 87)\n , (\"\u00c3\u00a5ttisyv\", 87)\n , (\"\u00c3\u00a5tti\u00c3\u00a5tte\", 88)\n , (\"\u00c3\u00a5ttini\", 89)\n , (\"nittien\", 91)\n , (\"nitti\u00c3\u00a9n\", 91)\n , (\"nittito\", 92)\n , (\"nittitre\", 93)\n , (\"nittifire\", 94)\n , (\"nittifem\", 95)\n , (\"nittiseks\", 96)\n , (\"nittisju\", 97)\n , (\"nittisyv\", 97)\n , (\"nitti\u00c3\u00a5tte\", 98)\n , (\"nittini\", 99)\n ]\n\nruleInteger4 :: Rule\nruleInteger4 = Rule\n { name = \"integer (21..99)\"\n , pattern =\n [ regex \"(tjueen|tjue\u00c3\u00a9n|tjueto|tjuetre|tjuefire|tjuefem|tjueseks|tjuesju|tjuesyv|tjue\u00c3\u00a5tte|tjueni\\\n \\|trettien|tretti\u00c3\u00a9n|trettito|trettitre|trettifire|trettifem|trettiseks|trettisju|trettisyv|tretti\u00c3\u00a5tte|trettini\\\n \\|f\u00c3\u00b8rtien|f\u00c3\u00b8rti\u00c3\u00a9n|f\u00c3\u00b8rtito|f\u00c3\u00b8rtitre|f\u00c3\u00b8rtifire|f\u00c3\u00b8rtifem|f\u00c3\u00b8rtiseks|f\u00c3\u00b8rtisju|f\u00c3\u00b8rtisyv|f\u00c3\u00b8rti\u00c3\u00a5tte|f\u00c3\u00b8rtini\\\n \\|femtien|femti\u00c3\u00a9n|femtito|femtitre|femtifire|femtifem|femtiseks|femtisju|femtisyv|femti\u00c3\u00a5tte|femtini\\\n \\|sekstien|seksti\u00c3\u00a9n|sekstito|sekstitre|sekstifire|sekstifem|sekstiseks|sekstisju|sekstisyv|seksti\u00c3\u00a5tte|sekstini\\\n \\|syttien|sytti\u00c3\u00a9n|syttito|syttitre|syttifire|syttifem|syttiseks|syttisju|syttisyv|sytti\u00c3\u00a5tte|syttini\\\n \\|s\u00c3\u00b8ttien|s\u00c3\u00b8tti\u00c3\u00a9n|s\u00c3\u00b8ttito|s\u00c3\u00b8ttitre|s\u00c3\u00b8ttifire|s\u00c3\u00b8ttifem|s\u00c3\u00b8ttiseks|s\u00c3\u00b8ttisju|s\u00c3\u00b8ttisyv|s\u00c3\u00b8tti\u00c3\u00a5tte|s\u00c3\u00b8ttini\\\n \\|\u00c3\u00a5ttien|\u00c3\u00a5tti\u00c3\u00a9n|\u00c3\u00a5ttito|\u00c3\u00a5ttitre|\u00c3\u00a5ttifire|\u00c3\u00a5ttifem|\u00c3\u00a5ttiseks|\u00c3\u00a5ttisju|\u00c3\u00a5ttisyv|\u00c3\u00a5tti\u00c3\u00a5tte|\u00c3\u00a5ttini\\\n \\|nittien|nitti\u00c3\u00a9n|nittito|nittitre|nittifire|nittifem|nittiseks|nittisju|nittisyv|nitti\u00c3\u00a5tte|nittini\\\n \\)\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) twentyToHundredMap >>= integer\n _ -> Nothing\n }\n\n\ntensMap :: HashMap Text Integer\ntensMap = HashMap.fromList\n [ ( \"tyve\" , 20 )\n , ( \"tjue\" , 20 )\n , ( \"tredve\" , 30 )\n , ( \"tretti\" , 30 )\n , ( \"f\u00c3\u00b8rti\" , 40 )\n , ( \"femti\" , 50 )\n , ( \"seksti\" , 60 )\n , ( \"sytti\" , 70 )\n , ( \"s\u00c3\u00b8tti\" , 70 )\n , ( \"\u00c3\u00a5tti\" , 80 )\n , ( \"nitti\" , 90 )\n ]\n\nruleInteger2 :: Rule\nruleInteger2 = Rule\n { name = \"integer (20..90)\"\n , pattern =\n [ regex \"(tyve|tjue|tredve|tretti|f\u00c3\u00b8rti|femti|seksti|sytti|s\u00c3\u00b8tti|\u00c3\u00a5tti|nitti)\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) tensMap >>= integer\n _ -> Nothing\n }\n\nruleNumeralDotNumeral :: Rule\nruleNumeralDotNumeral = Rule\n { name = \"number dot number\"\n , pattern =\n [ dimension Numeral\n , regex \"komma\"\n , Predicate $ not . hasGrain\n ]\n , prod = \\case\n (Token Numeral nd1:_:Token Numeral nd2:_) ->\n double $ TNumeral.value nd1 + decimalsToDouble (TNumeral.value nd2)\n _ -> Nothing\n }\n\nruleIntegerWithThousandsSeparator :: Rule\nruleIntegerWithThousandsSeparator = Rule\n { name = \"integer with thousands separator .\"\n , pattern =\n [ regex \"(\\\\d{1,3}((?:\\\\.| )\\\\d\\\\d\\\\d){1,5})\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):_) -> parseDouble\n (Text.replace \" \" Text.empty $ Text.replace \".\" Text.empty $ match)\n >>= double\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleAPair\n , ruleDecimalNumeral\n , ruleDecimalWithThousandsSeparator\n , ruleDozen\n , ruleFew\n , ruleInteger\n , ruleInteger2\n , ruleInteger3\n , ruleInteger4\n , ruleIntegerWithThousandsSeparator\n , ruleIntersect\n , ruleIntersectWithAnd\n , ruleMultiply\n , ruleNumeralDotNumeral\n , ruleNumeralsPrefixWithNegativeOrMinus\n , ruleNumeralsSuffixesKMG\n , rulePowersOfTen\n , ruleSingle\n ]\n", "num_lines": 452} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Numeral.NL.Corpus\n ( corpus\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Locale\nimport Duckling.Numeral.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale NL Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (NumeralValue 0)\n [ \"0\"\n , \"nul\"\n , \"geen\"\n , \"niks\"\n ]\n , examples (NumeralValue 1)\n [ \"1\"\n , \"een\"\n , \"\u00c3\u00a9\u00c3\u00a9n\"\n ]\n , examples (NumeralValue 2)\n [ \"2\"\n , \"twee\"\n ]\n , examples (NumeralValue 33)\n [ \"33\"\n , \"3 en 30\"\n , \"drieendertig\"\n , \"drie\u00c3\u00abndertig\"\n , \"drie en dertig\"\n , \"0033\"\n ]\n , examples (NumeralValue 12)\n [ \"twaalf\"\n , \"dozijn\"\n ]\n , examples (NumeralValue 14)\n [ \"14\"\n , \"veertien\"\n ]\n , examples (NumeralValue 16)\n [ \"16\"\n , \"zestien\"\n ]\n , examples (NumeralValue 17)\n [ \"17\"\n , \"zeventien\"\n ]\n , examples (NumeralValue 18)\n [ \"18\"\n , \"achttien\"\n ]\n , examples (NumeralValue 1.1)\n [ \"1,1\"\n , \"1,10\"\n , \"01,10\"\n ]\n , examples (NumeralValue 0.77)\n [ \"0,77\"\n , \",77\"\n ]\n , examples (NumeralValue 100000)\n [ \"100.000\"\n , \"100.000,0\"\n , \"100000\"\n , \"100K\"\n , \"100k\"\n , \"honderd duizend\"\n ]\n , examples (NumeralValue 300)\n [ \"3 honderd\"\n , \"drie honderd\"\n ]\n , examples (NumeralValue 5000)\n [ \"5 duizend\"\n , \"vijf duizend\"\n , \"5.000\"\n , \"5.000,00\"\n ]\n , examples (NumeralValue 144)\n [ \"gros\"\n ]\n , examples (NumeralValue 122)\n [ \"honderd twee\u00c3\u00abntwintig\"\n , \"honderd tweeentwintig\"\n , \"honderd twee en twintig\"\n ]\n , examples (NumeralValue 20000)\n [ \"twintig duizend\"\n , \"20.000\"\n , \"20000\"\n , \"20.000,00\"\n ]\n , examples (NumeralValue 0.2)\n [ \"1/5\"\n , \"2/10\"\n , \"3/15\"\n , \"20/100\"\n ]\n ]\n", "num_lines": 118} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE NoRebindableSyntax #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Numeral.NL.Rules\n ( rules\n ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport Data.Maybe\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers\nimport Duckling.Numeral.Types (NumeralData (..))\nimport Duckling.Regex.Types\nimport Duckling.Types\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleNumeralsPrefixWithNegativeOrMinus :: Rule\nruleNumeralsPrefixWithNegativeOrMinus = Rule\n { name = \"numbers prefix with -, negative or minus\"\n , pattern =\n [ regex \"-|min|minus|negatief\"\n , Predicate isPositive\n ]\n , prod = \\tokens -> case tokens of\n (_:Token Numeral nd:_) -> double (TNumeral.value nd * (-1))\n _ -> Nothing\n }\n\nruleFew :: Rule\nruleFew = Rule\n { name = \"few\"\n , pattern =\n [ regex \"meerdere\"\n ]\n , prod = \\_ -> integer 3\n }\n\nruleTen :: Rule\nruleTen = Rule\n { name = \"ten\"\n , pattern =\n [ regex \"tien\"\n ]\n , prod = \\_ -> integer 10 >>= withGrain 1\n }\n\nruleDecimalWithThousandsSeparator :: Rule\nruleDecimalWithThousandsSeparator = Rule\n { name = \"decimal with thousands separator\"\n , pattern =\n [ regex \"(\\\\d+(\\\\.\\\\d\\\\d\\\\d)+(,\\\\d+)?)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):\n _) -> let fmt = Text.replace \",\" \".\" $ Text.replace \".\" Text.empty match\n in parseDouble fmt >>= double\n _ -> Nothing\n }\n\nruleDecimalNumeral :: Rule\nruleDecimalNumeral = Rule\n { name = \"decimal number\"\n , pattern =\n [ regex \"(\\\\d*,\\\\d+)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):\n _) -> parseDecimal False match\n _ -> Nothing\n }\n\n-- TODO: Single-word composition (#110)\nruleInteger3 :: Rule\nruleInteger3 = Rule\n { name = \"integer ([2-9][1-9])\"\n , pattern =\n [ regex \"(een|twee|drie|vier|vijf|zes|zeven|acht|negen)(?:e|\u00c3\u00ab)n(twintig|dertig|veertig|vijftig|zestig|zeventig|tachtig|negentig)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (m1:m2:_)):_) -> do\n v1 <- HashMap.lookup (Text.toLower m1) zeroNineteenMap\n v2 <- HashMap.lookup (Text.toLower m2) dozenMap\n integer $ v1 + v2\n _ -> Nothing\n }\n\nruleMultiply :: Rule\nruleMultiply = Rule\n { name = \"compose by multiplication\"\n , pattern =\n [ dimension Numeral\n , Predicate isMultipliable\n ]\n , prod = \\tokens -> case tokens of\n (token1:token2:_) -> multiply token1 token2\n _ -> Nothing\n }\n\nruleIntersect :: Rule\nruleIntersect = Rule\n { name = \"intersect\"\n , pattern =\n [ Predicate hasGrain\n , Predicate $ and . sequence [not . isMultipliable, isPositive]\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = val1, TNumeral.grain = Just g}:\n Token Numeral NumeralData{TNumeral.value = val2}:\n _) | (10 ** fromIntegral g) > val2 -> double $ val1 + val2\n _ -> Nothing\n }\n\nruleNumeralsSuffixesKMG :: Rule\nruleNumeralsSuffixesKMG = Rule\n { name = \"numbers suffixes (K, M, G)\"\n , pattern =\n [ dimension Numeral\n , regex \"([kmg])(?=[\\\\W\\\\$\u00e2\u201a\u00ac]|$)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v}:\n Token RegexMatch (GroupMatch (match:_)):\n _) -> case Text.toLower match of\n \"k\" -> double $ v * 1e3\n \"m\" -> double $ v * 1e6\n \"g\" -> double $ v * 1e9\n _ -> Nothing\n _ -> Nothing\n }\n\nruleNumeralsEn :: Rule\nruleNumeralsEn = Rule\n { name = \"numbers en\"\n , pattern =\n [ Predicate $ numberBetween 1 10\n , regex \"-?en-?\"\n , oneOf [20, 30 .. 90]\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v1}:\n _:\n Token Numeral NumeralData{TNumeral.value = v2}:\n _) -> double $ v1 + v2\n _ -> Nothing\n }\n\nrulePowersOfTen :: Rule\nrulePowersOfTen = Rule\n { name = \"powers of tens\"\n , pattern =\n [ regex \"(honderd|duizend|miljoen)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of\n \"honderd\" -> double 1e2 >>= withGrain 2 >>= withMultipliable\n \"duizend\" -> double 1e3 >>= withGrain 3 >>= withMultipliable\n \"miljoen\" -> double 1e6 >>= withGrain 6 >>= withMultipliable\n _ -> Nothing\n _ -> Nothing\n }\n\nruleCouple :: Rule\nruleCouple = Rule\n { name = \"couple\"\n , pattern =\n [ regex \"(een )?paar\"\n ]\n , prod = \\_ -> integer 2\n }\n\nruleDozen :: Rule\nruleDozen = Rule\n { name = \"dozen\"\n , pattern =\n [ regex \"dozijn\"\n ]\n , prod = \\_ -> integer 12 >>= withGrain 1\n }\n\nruleGross :: Rule\nruleGross = Rule\n { name = \"gros\"\n , pattern =\n [ regex \"gros\"\n ]\n , prod = \\_ -> integer 144 >>= withGrain 1\n }\n\nzeroNineteenMap :: HashMap Text Integer\nzeroNineteenMap = HashMap.fromList\n [ (\"niks\", 0)\n , (\"nul\", 0)\n , (\"geen\", 0)\n , (\"\u00c3\u00a9\u00c3\u00a9n\", 1)\n , (\"een\", 1)\n , (\"twee\", 2)\n , (\"drie\", 3)\n , (\"vier\", 4)\n , (\"vijf\", 5)\n , (\"zes\", 6)\n , (\"zeven\", 7)\n , (\"acht\", 8)\n , (\"negen\", 9)\n , (\"tien\", 10)\n , (\"elf\", 11)\n , (\"twaalf\", 12)\n , (\"dertien\", 13)\n , (\"veertien\", 14)\n , (\"vijftien\", 15)\n , (\"zestien\", 16)\n , (\"zeventien\", 17)\n , (\"achttien\", 18)\n , (\"negentien\", 19)\n ]\n\nruleInteger :: Rule\nruleInteger = Rule\n { name = \"integer (0..19)\"\n , pattern =\n [ regex \"(geen|nul|niks|een|\u00c3\u00a9\u00c3\u00a9n|twee|drie|vier|vijftien|vijf|zestien|zes|zeventien|zeven|achttien|acht|negentien|negen|tien|elf|twaalf|dertien|veertien)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) zeroNineteenMap >>= integer\n _ -> Nothing\n }\n\ndozenMap :: HashMap Text Integer\ndozenMap = HashMap.fromList\n [ (\"twintig\", 20)\n , (\"dertig\", 30)\n , (\"veertig\", 40)\n , (\"vijftig\", 50)\n , (\"zestig\", 60)\n , (\"zeventig\", 70)\n , (\"tachtig\", 80)\n , (\"negentig\", 90)\n ]\n\nruleInteger2 :: Rule\nruleInteger2 = Rule\n { name = \"integer (20..90)\"\n , pattern =\n [ regex \"(twintig|dertig|veertig|vijftig|zestig|zeventig|tachtig|negentig)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) dozenMap >>= integer\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleCouple\n , ruleDecimalNumeral\n , ruleDecimalWithThousandsSeparator\n , ruleDozen\n , ruleGross\n , ruleFew\n , ruleInteger\n , ruleInteger2\n , ruleInteger3\n , ruleIntersect\n , ruleMultiply\n , ruleNumeralsEn\n , ruleNumeralsPrefixWithNegativeOrMinus\n , ruleNumeralsSuffixesKMG\n , rulePowersOfTen\n , ruleTen\n ]\n", "num_lines": 285} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Numeral.PL.Corpus\n ( corpus ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Locale\nimport Duckling.Numeral.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale PL Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (NumeralValue 0)\n [ \"0\"\n , \"nic\"\n , \"zero\"\n ]\n , examples (NumeralValue 1)\n [ \"1\"\n , \"jeden\"\n , \"pojedynczy\"\n ]\n , examples (NumeralValue 2)\n [ \"2\"\n , \"dwa\"\n , \"para\"\n ]\n , examples (NumeralValue 33)\n [ \"33\"\n , \"trzydzie\u00c5\u203aci trzy\"\n , \"0033\"\n ]\n , examples (NumeralValue 14)\n [ \"14\"\n , \"czterna\u00c5\u203acie\"\n ]\n , examples (NumeralValue 16)\n [ \"16\"\n , \"szesna\u00c5\u203acie\"\n ]\n , examples (NumeralValue 17)\n [ \"17\"\n , \"siedemna\u00c5\u203acie\"\n ]\n , examples (NumeralValue 18)\n [ \"18\"\n , \"osiemna\u00c5\u203acie\"\n ]\n , examples (NumeralValue 1.1)\n [ \"1.1\"\n , \"1.10\"\n , \"01.10\"\n ]\n , examples (NumeralValue 0.77)\n [ \"0.77\"\n , \".77\"\n ]\n , examples (NumeralValue 100000)\n [ \"100,000\"\n , \"100000\"\n , \"100K\"\n , \"100k\"\n ]\n , examples (NumeralValue 3000000)\n [ \"3M\"\n , \"3000K\"\n , \"3000000\"\n , \"3,000,000\"\n ]\n , examples (NumeralValue 1200000)\n [ \"1,200,000\"\n , \"1200000\"\n , \"1.2M\"\n , \"1200K\"\n ]\n , examples (NumeralValue (-1200000))\n [ \"- 1,200,000\"\n , \"-1200000\"\n , \"minus 1,200,000\"\n , \"-1.2M\"\n , \"-1200K\"\n , \"-.0012G\"\n ]\n , examples (NumeralValue 5000)\n [ \"5 tysi\u00c4\u2122cy\"\n , \"pi\u00c4\u2122\u00c4\u2021 tysi\u00c4\u2122cy\"\n ]\n , examples (NumeralValue 79)\n [ \"siedemdziesi\u00c4\u2026t dziewi\u00c4\u2122\u00c4\u2021\"\n , \"siedemdziesi\u00c4\u2122ciu dziewi\u00c4\u2122ciu\"\n ]\n , examples (NumeralValue 84)\n [ \"osiemdziesi\u00c4\u2026t cztery\"\n , \"osiemdziesiat cztery\"\n , \"osiemdziesi\u00c4\u2122ciu czterem\"\n , \"osiemdziesieciu czterem\"\n ]\n , examples (NumeralValue 92)\n [ \"dziewi\u00c4\u2122\u00c4\u2021dziesi\u00c4\u2026t dwa\"\n , \"dziewiecdziesiat dwa\"\n , \"dziewi\u00c4\u2122\u00c4\u2021dziesi\u00c4\u2122ciu dw\u00c3\u00b3m\"\n , \"dziewiecdziesieciu dwom\"\n ]\n , examples (NumeralValue 122)\n [ \"sto dwadzie\u00c5\u203acia dwa\"\n ]\n , examples (NumeralValue 200000)\n [ \"dwie\u00c5\u203acie tysi\u00c4\u2122cy\"\n ]\n , examples (NumeralValue 21011)\n [ \"dwadzie\u00c5\u203acia jeden tysi\u00c4\u2122cy i jedena\u00c5\u203acie\"\n , \"dwadzie\u00c5\u203acia jeden tysi\u00c4\u2122cy jedena\u00c5\u203acie\"\n ]\n , examples (NumeralValue 721012)\n [ \"siedemset dwadzie\u00c5\u203acia jeden tysi\u00c4\u2122cy dwana\u00c5\u203acie\"\n , \"siedemset dwadzie\u00c5\u203acia jeden tysi\u00c4\u2122cy i dwana\u00c5\u203acie\"\n ]\n , examples (NumeralValue 65000000)\n [ \"sze\u00c5\u203a\u00c4\u2021dziesi\u00c4\u2026t pi\u00c4\u2122\u00c4\u2021 milion\u00c3\u00b3w\"\n ]\n , examples (NumeralValue 31256721)\n [ \"trzydzie\u00c5\u203aci jeden milion\u00c3\u00b3w dwie\u00c5\u203acie pi\u00c4\u2122\u00c4\u2021dziesi\u00c4\u2026t sze\u00c5\u203a\u00c4\u2021 tysi\u00c4\u2122cy siedemset dwadzie\u00c5\u203acia jeden\"\n ]\n , examples (NumeralValue 15)\n [ \"pi\u00c4\u2122tnasta\"\n ]\n ]\n", "num_lines": 141} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Numeral.PL.Rules\n ( rules\n ) where\n\nimport Data.Maybe\nimport Data.String\nimport Prelude\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers\nimport Duckling.Numeral.Types (NumeralData (..))\nimport Duckling.Regex.Types\nimport Duckling.Types\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleSixteen :: Rule\nruleSixteen = Rule\n { name = \"sixteen\"\n , pattern =\n [ regex \"szesna(s|\u00c5\u203a)(tu|cie|toma)\"\n ]\n , prod = \\_ -> integer 16\n }\n\nruleFourteen :: Rule\nruleFourteen = Rule\n { name = \"fourteen\"\n , pattern =\n [ regex \"czterna(s|\u00c5\u203a)(tu|cie|toma)\"\n ]\n , prod = \\_ -> integer 14\n }\n\nruleTwo :: Rule\nruleTwo = Rule\n { name = \"two\"\n , pattern =\n [ regex \"dw(a|(o|\u00c3\u00b3)(ch|m)|oma|iema|ie)\"\n ]\n , prod = \\_ -> integer 2\n }\n\nruleSixty :: Rule\nruleSixty = Rule\n { name = \"sixty\"\n , pattern =\n [ regex \"sze(\u00c5\u203a\u00c4\u2021)dziesi(\u00c4\u2026)t|sze(\u00c5\u203a\u00c4\u2021)dziesi(\u00c4\u2122)ci(u|oma)\"\n ]\n , prod = \\_ -> integer 60\n }\n\nruleSeventy :: Rule\nruleSeventy = Rule\n { name = \"seventy\"\n , pattern =\n [ regex \"siedemdziesi((a|\u00c4\u2026)t|(e|\u00c4\u2122)ci(u|oma))\"\n ]\n , prod = \\_ -> integer 70\n }\n\nruleEighty :: Rule\nruleEighty = Rule\n { name = \"eighty\"\n , pattern =\n [ regex \"osiemdziesi((a|\u00c4\u2026)t|(e|\u00c4\u2122)ci(u|oma))\"\n ]\n , prod = \\_ -> integer 80\n }\n\nruleNinety :: Rule\nruleNinety = Rule\n { name = \"ninety\"\n , pattern =\n [ regex \"dziewi(e|\u00c4\u2122)(c|\u00c4\u2021)dziesi((a|\u00c4\u2026)|(e|\u00c4\u2122))(t|ci(u|oma))\"\n ]\n , prod = \\_ -> integer 90\n }\n\nruleIntersectWithAnd :: Rule\nruleIntersectWithAnd = Rule\n { name = \"intersect (with and)\"\n , pattern =\n [ Predicate hasGrain\n , regex \"i|a\"\n , Predicate $ and . sequence [not . isMultipliable, isPositive]\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = val1, TNumeral.grain = Just g}:\n _:\n Token Numeral NumeralData{TNumeral.value = val2}:\n _) | (10 ** fromIntegral g) > val2 -> double $ val1 + val2\n _ -> Nothing\n }\n\nruleNumeralsPrefixWithNegativeOrMinus :: Rule\nruleNumeralsPrefixWithNegativeOrMinus = Rule\n { name = \"numbers prefix with -, negative or minus\"\n , pattern =\n [ regex \"-|minus|negative\"\n , Predicate isPositive\n ]\n , prod = \\tokens -> case tokens of\n (_:Token Numeral nd:_) -> double (TNumeral.value nd * (-1))\n _ -> Nothing\n }\n\nruleOne :: Rule\nruleOne = Rule\n { name = \"one\"\n , pattern =\n [ regex \"jed(en|nego|nemu|nym|nej|n(a|\u00c4\u2026))\"\n ]\n , prod = \\_ -> integer 1\n }\n\nruleTen :: Rule\nruleTen = Rule\n { name = \"ten\"\n , pattern =\n [ regex \"dzisi(e|\u00c4\u2122)(\u00c4\u2021|c)(iu|ioma)?\"\n ]\n , prod = \\_ -> integer 10\n }\n\nruleSpecialCompositionForMissingHundredsLikeInOneTwentyTwo :: Rule\nruleSpecialCompositionForMissingHundredsLikeInOneTwentyTwo = Rule\n { name = \"special composition for missing hundreds like in one twenty two\"\n , pattern =\n [ Predicate $ numberBetween 1 10\n , Predicate $ numberBetween 10 100\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v1}:\n Token Numeral NumeralData{TNumeral.value = v2}:\n _) -> double (v1 * 100 + v2)\n _ -> Nothing\n }\n\nruleDecimalWithThousandsSeparator :: Rule\nruleDecimalWithThousandsSeparator = Rule\n { name = \"decimal with thousands separator\"\n , pattern =\n [ regex \"(\\\\d+(,\\\\d\\\\d\\\\d)+\\\\.\\\\d+)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n parseDouble (Text.replace \",\" Text.empty match) >>= double\n _ -> Nothing\n }\n\nruleNine :: Rule\nruleNine = Rule\n { name = \"nine\"\n , pattern =\n [ regex \"dziewi(e|\u00c4\u2122)(\u00c4\u2021|c)(iu|ioma)?\"\n ]\n , prod = \\_ -> integer 9\n }\n\nruleNumeral8 :: Rule\nruleNumeral8 = Rule\n { name = \"number 800\"\n , pattern =\n [ regex \"(osiem(set| setek))\"\n ]\n , prod = \\_ -> integer 800 >>= withGrain 2\n }\n\nruleTwelve :: Rule\nruleTwelve = Rule\n { name = \"twelve\"\n , pattern =\n [ regex \"dwunast(u|oma)|dwana(\u00c5\u203a|s)cie\"\n ]\n , prod = \\_ -> integer 12\n }\n\nruleDecimalNumeral :: Rule\nruleDecimalNumeral = Rule\n { name = \"decimal number\"\n , pattern =\n [ regex \"(\\\\d*\\\\.\\\\d+)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> parseDecimal True match\n _ -> Nothing\n }\n\nruleFifteen :: Rule\nruleFifteen = Rule\n { name = \"fifteen\"\n , pattern =\n [ regex \"pi(\u00c4\u2122)tna(s|\u00c5\u203a)(ta|tu|cie|toma)\"\n ]\n , prod = \\_ -> integer 15\n }\n\nruleEleven :: Rule\nruleEleven = Rule\n { name = \"eleven\"\n , pattern =\n [ regex \"jedena(stu|(s|\u00c5\u203a)cie|stoma)\"\n ]\n , prod = \\_ -> integer 11\n }\n\nruleThirteen :: Rule\nruleThirteen = Rule\n { name = \"thirteen\"\n , pattern =\n [ regex \"trzyna(\u00c5\u203a|s)(tu|cie|toma)\"\n ]\n , prod = \\_ -> integer 13\n }\n\nruleThirty :: Rule\nruleThirty = Rule\n { name = \"thirty\"\n , pattern =\n [ regex \"trzydzie(\u00c5\u203a)ci|trzydziest(u|oma)\"\n ]\n , prod = \\_ -> integer 30\n }\n\nruleNumeral2 :: Rule\nruleNumeral2 = Rule\n { name = \"number 200\"\n , pattern =\n [ regex \"dwie((\u00c5\u203a)cie| setki)\"\n ]\n , prod = \\_ -> integer 200 >>= withGrain 2\n }\n\nruleSeventeen :: Rule\nruleSeventeen = Rule\n { name = \"seventeen\"\n , pattern =\n [ regex \"siedemna(s|\u00c5\u203a)(tu|cie|toma)\"\n ]\n , prod = \\_ -> integer 17\n }\n\nruleNumeral :: Rule\nruleNumeral = Rule\n { name = \"number 100\"\n , pattern =\n [ regex \"(sto|setki)\"\n ]\n , prod = \\_ -> integer 100 >>= withGrain 2\n }\n\nruleNumeral9 :: Rule\nruleNumeral9 = Rule\n { name = \"number 900\"\n , pattern =\n [ regex \"dziewi(\u00c4\u2122\u00c4\u2021)(set| setek)\"\n ]\n , prod = \\_ -> integer 900 >>= withGrain 2\n }\n\nruleSingle :: Rule\nruleSingle = Rule\n { name = \"single\"\n , pattern =\n [ regex \"pojedynczy\"\n ]\n , prod = \\_ -> integer 1\n }\n\nruleTwenty :: Rule\nruleTwenty = Rule\n { name = \"twenty\"\n , pattern =\n [ regex \"dwadzie(\u00c5\u203a|s)cia|dwudziest(u|oma)\"\n ]\n , prod = \\_ -> integer 20\n }\n\nruleAFew :: Rule\nruleAFew = Rule\n { name = \"a few\"\n , pattern =\n [ regex \"kilk(a|u)\"\n ]\n , prod = \\_ -> integer 3\n }\n\nruleEight :: Rule\nruleEight = Rule\n { name = \"eight\"\n , pattern =\n [ regex \"o(s|\u00c5\u203a)(iem|miu|mioma)\"\n ]\n , prod = \\_ -> integer 8\n }\n\nruleNumeral5 :: Rule\nruleNumeral5 = Rule\n { name = \"number 500\"\n , pattern =\n [ regex \"pi(\u00c4\u2122\u00c4\u2021)(set| setek)\"\n ]\n , prod = \\_ -> integer 500 >>= withGrain 2\n }\n\nruleNumeral3 :: Rule\nruleNumeral3 = Rule\n { name = \"number 300\"\n , pattern =\n [ regex \"(trzy(sta| setki))\"\n ]\n , prod = \\_ -> integer 300 >>= withGrain 2\n }\n\nruleZero :: Rule\nruleZero = Rule\n { name = \"zero\"\n , pattern =\n [ regex \"(zero|nic)\"\n ]\n , prod = \\_ -> integer 0\n }\n\nruleThousand :: Rule\nruleThousand = Rule\n { name = \"thousand\"\n , pattern =\n [ regex \"ty(s|\u00c5\u203a)i(a|\u00c4\u2026|\u00c4\u2122)c(e|y)?\"\n ]\n , prod = \\_ -> integer 1000 >>= withGrain 3 >>= withMultipliable\n }\n\nruleMillion :: Rule\nruleMillion = Rule\n { name = \"million\"\n , pattern =\n [ regex \"milion(y|(\u00c3\u00b3)w)?\"\n ]\n , prod = \\_ -> integer 1000000 >>= withGrain 6 >>= withMultipliable\n }\n\nruleIntersect :: Rule\nruleIntersect = Rule\n { name = \"intersect\"\n , pattern =\n [ Predicate hasGrain\n , Predicate $ and . sequence [not . isMultipliable, isPositive]\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = val1, TNumeral.grain = Just g}:\n Token Numeral NumeralData{TNumeral.value = val2}:\n _) | (10 ** fromIntegral g) > val2 -> double $ val1 + val2\n _ -> Nothing\n }\n\nruleMultiply :: Rule\nruleMultiply = Rule\n { name = \"compose by multiplication\"\n , pattern =\n [ dimension Numeral\n , Predicate isMultipliable\n ]\n , prod = \\tokens -> case tokens of\n (token1:token2:_) -> multiply token1 token2\n _ -> Nothing\n }\n\nruleThree :: Rule\nruleThree = Rule\n { name = \"three\"\n , pattern =\n [ regex \"trz(y|ema|ech)\"\n ]\n , prod = \\_ -> integer 3\n }\n\nruleFour :: Rule\nruleFour = Rule\n { name = \"four\"\n , pattern =\n [ regex \"czter(ej|y|ech|em|ema)\"\n ]\n , prod = \\_ -> integer 4\n }\n\nruleNumeralsSuffixesKMG :: Rule\nruleNumeralsSuffixesKMG = Rule\n { name = \"numbers suffixes (K, M, G)\"\n , pattern =\n [ dimension Numeral\n , regex \"([kmg])(?=[\\\\W\\\\$\u00e2\u201a\u00ac]|$)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v}:\n Token RegexMatch (GroupMatch (match:_)):\n _) -> case Text.toLower match of\n \"k\" -> double $ v * 1e3\n \"m\" -> double $ v * 1e6\n \"g\" -> double $ v * 1e9\n _ -> Nothing\n _ -> Nothing\n }\n\nruleNumeral7 :: Rule\nruleNumeral7 = Rule\n { name = \"number 700\"\n , pattern =\n [ regex \"(siedem(set| setek))\"\n ]\n , prod = \\_ -> integer 700 >>= withGrain 2\n }\n\nruleAPair :: Rule\nruleAPair = Rule\n { name = \"a pair\"\n , pattern =\n [ regex \"para?\"\n ]\n , prod = \\_ -> integer 2\n }\n\nruleCouple :: Rule\nruleCouple = Rule\n { name = \"couple\"\n , pattern =\n [ regex \"pare\"\n ]\n , prod = \\_ -> integer 2\n }\n\nruleSix :: Rule\nruleSix = Rule\n { name = \"six\"\n , pattern =\n [ regex \"sze(s|\u00c5\u203a)(c|\u00c4\u2021)(iu|oma|u)?\"\n ]\n , prod = \\_ -> integer 6\n }\n\nruleNumeral6 :: Rule\nruleNumeral6 = Rule\n { name = \"number 600\"\n , pattern =\n [ regex \"(sze\u00c5\u203a\u00c4\u2021(set| setek))\"\n ]\n , prod = \\_ -> integer 600 >>= withGrain 2\n }\n\nruleNumeral4 :: Rule\nruleNumeral4 = Rule\n { name = \"number 400\"\n , pattern =\n [ regex \"(cztery(sta| setki))\"\n ]\n , prod = \\_ -> integer 400 >>= withGrain 2\n }\n\nruleFive :: Rule\nruleFive = Rule\n { name = \"five\"\n , pattern =\n [ regex \"pi(e|\u00c4\u2122)(c|\u00c4\u2021)(iu|oma|u)?\"\n ]\n , prod = \\_ -> integer 5\n }\n\nruleFourty :: Rule\nruleFourty = Rule\n { name = \"fou?rty\"\n , pattern =\n [ regex \"czterdzie(\u00c5\u203a)ci|czterdziest(u|oma)\"\n ]\n , prod = \\_ -> integer 40\n }\n\nruleDozen :: Rule\nruleDozen = Rule\n { name = \"dozen\"\n , pattern =\n [ regex \"tuzin\"\n ]\n , prod = \\_ -> integer 12 >>= withMultipliable\n }\n\nruleSeven :: Rule\nruleSeven = Rule\n { name = \"seven\"\n , pattern =\n [ regex \"sied(miu|em|mioma)\"\n ]\n , prod = \\_ -> integer 7\n }\n\nruleNineteen :: Rule\nruleNineteen = Rule\n { name = \"nineteen\"\n , pattern =\n [ regex \"dziewietna(s|\u00c5\u203a)(tu|cie|toma)\"\n ]\n , prod = \\_ -> integer 19\n }\n\nruleInteger2 :: Rule\nruleInteger2 = Rule\n { name = \"integer 21..99\"\n , pattern =\n [ oneOf [20, 30 .. 90]\n , Predicate $ numberBetween 1 10\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v1}:\n Token Numeral NumeralData{TNumeral.value = v2}:\n _) -> double $ v1 + v2\n _ -> Nothing\n }\n\nruleEighteen :: Rule\nruleEighteen = Rule\n { name = \"eighteen\"\n , pattern =\n [ regex \"osiemna(s|\u00c5\u203a)(tu|cie|toma)\"\n ]\n , prod = \\_ -> integer 18\n }\n\nruleNumeralDotNumeral :: Rule\nruleNumeralDotNumeral = Rule\n { name = \"number dot number\"\n , pattern =\n [ dimension Numeral\n , regex \"dot|point\"\n , Predicate $ not . hasGrain\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral nd1:_:Token Numeral nd2:_) ->\n double $ TNumeral.value nd1 + decimalsToDouble (TNumeral.value nd2)\n _ -> Nothing\n }\n\nruleIntegerWithThousandsSeparator :: Rule\nruleIntegerWithThousandsSeparator = Rule\n { name = \"integer with thousands separator ,\"\n , pattern =\n [ regex \"(\\\\d{1,3}(,\\\\d\\\\d\\\\d){1,5})\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n parseDouble (Text.replace \",\" Text.empty match) >>= double\n _ -> Nothing\n }\n\nruleFifty :: Rule\nruleFifty = Rule\n { name = \"fifty\"\n , pattern =\n [ regex \"pi(\u00c4\u2122\u00c4\u2021)dziesi(\u00c4\u2026)t|pi(\u00c4\u2122\u00c4\u2021)dziesi(\u00c4\u2122)ci(u|oma)\"\n ]\n , prod = \\_ -> integer 50\n }\n\nrules :: [Rule]\nrules =\n [ ruleAFew\n , ruleAPair\n , ruleCouple\n , ruleDecimalNumeral\n , ruleDecimalWithThousandsSeparator\n , ruleDozen\n , ruleEight\n , ruleEighteen\n , ruleEighty\n , ruleEleven\n , ruleFifteen\n , ruleFifty\n , ruleFive\n , ruleFour\n , ruleFourteen\n , ruleFourty\n , ruleInteger2\n , ruleIntegerWithThousandsSeparator\n , ruleIntersect\n , ruleIntersectWithAnd\n , ruleMillion\n , ruleMultiply\n , ruleNine\n , ruleNineteen\n , ruleNinety\n , ruleNumeral\n , ruleNumeral2\n , ruleNumeral3\n , ruleNumeral4\n , ruleNumeral5\n , ruleNumeral6\n , ruleNumeral7\n , ruleNumeral8\n , ruleNumeral9\n , ruleNumeralDotNumeral\n , ruleNumeralsPrefixWithNegativeOrMinus\n , ruleNumeralsSuffixesKMG\n , ruleOne\n , ruleSeven\n , ruleSeventeen\n , ruleSeventy\n , ruleSingle\n , ruleSix\n , ruleSixteen\n , ruleSixty\n , ruleSpecialCompositionForMissingHundredsLikeInOneTwentyTwo\n , ruleTen\n , ruleThirteen\n , ruleThirty\n , ruleThousand\n , ruleThree\n , ruleTwelve\n , ruleTwenty\n , ruleTwo\n , ruleZero\n ]\n", "num_lines": 630} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Numeral.PT.Corpus\n ( corpus\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Locale\nimport Duckling.Numeral.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale PT Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (NumeralValue 1)\n [ \"1\"\n , \"um\"\n , \"Uma\"\n ]\n , examples (NumeralValue 2)\n [ \"2\"\n , \"dois\"\n , \"duas\"\n , \"pares de\"\n , \"um par de\"\n ]\n , examples (NumeralValue 3)\n [ \"3\"\n , \"tr\u00c3\u00aas\"\n , \"tres\"\n ]\n , examples (NumeralValue 6)\n [ \"6\"\n , \"seis\"\n ]\n , examples (NumeralValue 11)\n [ \"11\"\n , \"onze\"\n ]\n , examples (NumeralValue 12)\n [ \"12\"\n , \"doze\"\n , \"uma d\u00c3\u00bazia\"\n , \"uma duzia\"\n , \"uma duzias de\"\n ]\n , examples (NumeralValue 14)\n [ \"14\"\n , \"Catorze\"\n , \"quatorze\"\n ]\n , examples (NumeralValue 16)\n [ \"16\"\n , \"dezesseis\"\n , \"dezasseis\"\n ]\n , examples (NumeralValue 17)\n [ \"17\"\n , \"dezessete\"\n , \"dezassete\"\n ]\n , examples (NumeralValue 18)\n [ \"18\"\n , \"dezoito\"\n ]\n , examples (NumeralValue 19)\n [ \"19\"\n , \"dezenove\"\n , \"dezanove\"\n ]\n , examples (NumeralValue 21)\n [ \"21\"\n , \"vinte e um\"\n ]\n , examples (NumeralValue 23)\n [ \"23\"\n , \"vinte e tres\"\n , \"vinte e tr\u00c3\u00aas\"\n ]\n , examples (NumeralValue 24)\n [ \"24\"\n , \"vinte e quatro\"\n , \"duas d\u00c3\u00bazias\"\n , \"duas duzias\"\n ]\n , examples (NumeralValue 50)\n [ \"50\"\n , \"cinquenta\"\n , \"cinq\u00c3\u00bcenta\"\n , \"cincoenta\"\n ]\n , examples (NumeralValue 70)\n [ \"setenta\"\n ]\n , examples (NumeralValue 78)\n [ \"setenta e oito\"\n ]\n , examples (NumeralValue 80)\n [ \"oitenta\"\n ]\n , examples (NumeralValue 33)\n [ \"33\"\n , \"trinta e tr\u00c3\u00aas\"\n , \"trinta e tres\"\n ]\n , examples (NumeralValue 1.1)\n [ \"1,1\"\n , \"1,10\"\n , \"01,10\"\n ]\n , examples (NumeralValue 0.77)\n [ \"0,77\"\n , \",77\"\n , \"ponto setenta e sete\"\n ]\n , examples (NumeralValue 1000)\n [ \"mil\"\n ]\n , examples (NumeralValue 100000)\n [ \"100.000\"\n , \"100000\"\n , \"100K\"\n , \"100k\"\n , \"100.000,00\"\n ]\n , examples (NumeralValue 100)\n [ \"100\"\n , \"Cem\"\n ]\n , examples (NumeralValue 104)\n [ \"104\"\n , \"cento e quatro\"\n ]\n , examples (NumeralValue 243)\n [ \"243\"\n ,\"duzentos e quarenta e tres\"\n ]\n , examples (NumeralValue 300)\n [ \"trezentos\"\n ]\n , examples (NumeralValue 343)\n [ \"trezentos e quarenta e tres\"\n , \"343\"\n ]\n , examples (NumeralValue 891)\n [ \"oitocentos e noventa e um\"\n , \"891\"\n ]\n , examples (NumeralValue 2200)\n [ \"dois mil e duzentos\"\n ]\n , examples (NumeralValue 3000000)\n [ \"3M\"\n , \"3000K\"\n , \"3000000\"\n , \"3.000.000\"\n ]\n , examples (NumeralValue 1200000)\n [ \"1.200.000\"\n , \"1200000\"\n , \"1,2M\"\n , \"1200K\"\n , \",0012G\"\n ]\n , examples (NumeralValue (-1200000))\n [ \"- 1.200.000\"\n , \"-1200000\"\n , \"menos 1.200.000\"\n , \"-1,2M\"\n , \"-1200K\"\n , \"-,0012G\"\n , \"negativo 1,2M\"\n ]\n , examples (NumeralValue 1.5)\n [ \"1 ponto cinco\"\n , \"um ponto cinco\"\n , \"1,5\"\n ]\n , examples (NumeralValue 1200000.42)\n [ \"1.200.000,42\"\n ]\n , examples (NumeralValue 0.2)\n [ \"1/5\"\n , \"2/10\"\n , \"3/15\"\n , \"20/100\"\n ]\n ]\n", "num_lines": 201} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n{-# LANGUAGE NoRebindableSyntax #-}\n\nmodule Duckling.Numeral.PT.Rules\n ( rules\n ) where\n\nimport Control.Applicative ((<|>))\nimport Data.HashMap.Strict (HashMap)\nimport Data.Maybe\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers\nimport Duckling.Numeral.Types (NumeralData (..))\nimport Duckling.Regex.Types\nimport Duckling.Types\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleDozen :: Rule\nruleDozen = Rule\n { name = \"a dozen of\"\n , pattern =\n [ regex \"(uma )?d(u|\u00c3\u00ba)zias?( de)?\"\n ]\n , prod = \\_ -> integer 12 >>= withMultipliable >>= notOkForAnyTime\n }\n\nzeroNineteenMap :: HashMap Text Integer\nzeroNineteenMap = HashMap.fromList\n [ ( \"zero\" , 0 )\n , ( \"um\" , 1 )\n , ( \"uma\" , 1 )\n , ( \"dois\" , 2 )\n , ( \"duas\" , 2 )\n , ( \"tres\" , 3 )\n , ( \"tr\u00c3\u00aas\" , 3 )\n , ( \"quatro\" , 4 )\n , ( \"cinco\" , 5 )\n , ( \"seis\" , 6 )\n , ( \"sete\" , 7 )\n , ( \"oito\" , 8 )\n , ( \"nove\" , 9 )\n , ( \"dez\" , 10 )\n , ( \"onze\" , 11 )\n , ( \"doze\" , 12 )\n , ( \"treze\" , 13 )\n , ( \"catorze\" , 14 )\n , ( \"quatorze\" , 14 )\n , ( \"quinze\" , 15 )\n , ( \"dezesseis\" , 16 )\n , ( \"dezasseis\" , 16 )\n , ( \"dezessete\" , 17 )\n , ( \"dezassete\" , 17 )\n , ( \"dezoito\" , 18 )\n , ( \"dezenove\" , 19 )\n , ( \"dezanove\" , 19 )\n ]\n\ninformalMap :: HashMap Text Integer\ninformalMap = HashMap.fromList\n [ ( \"um par\" , 2 )\n , ( \"um par de\" , 2 )\n , ( \"par\" , 2 )\n , ( \"pares\" , 2 )\n , ( \"par de\" , 2 )\n , ( \"pares de\" , 2 )\n , ( \"um pouco\" , 3 )\n , ( \"pouco\" , 3 )\n ]\n\nruleToNineteen :: Rule\nruleToNineteen = Rule\n { name = \"integer (0..19)\"\n , pattern =\n [ regex \"(zero|d(oi|ua)s|(uma? )?par(es)?( de)?|tr(e|\u00c3\u00aa)s|(um )?pouco|uma?|(c|qu)atorze|quatro|quinze|cinco|dez[ea]sseis|seis|dez[ea]ssete|sete|dezoito|oito|dez[ea]nove|nove|dez|onze|doze|treze)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n let x = Text.toLower match in\n (HashMap.lookup x zeroNineteenMap >>= integer) <|>\n (HashMap.lookup x informalMap >>= integer >>= notOkForAnyTime)\n _ -> Nothing\n }\n\ntensMap :: HashMap Text Integer\ntensMap = HashMap.fromList\n [ ( \"vinte\" , 20 )\n , ( \"trinta\" , 30 )\n , ( \"quarenta\" , 40 )\n , ( \"cincoenta\" , 50 )\n , ( \"cinquenta\" , 50 )\n , ( \"cinq\u00c3\u00bcenta\" , 50 )\n , ( \"sessenta\" , 60 )\n , ( \"setenta\" , 70 )\n , ( \"oitenta\" , 80 )\n , ( \"noventa\" , 90 )\n ]\n\nruleTens :: Rule\nruleTens = Rule\n { name = \"tens (20..90)\"\n , pattern =\n [ regex \"(vinte|trinta|quarenta|cin(co|q[u\u00c3\u00bc])enta|sessenta|setenta|oitenta|noventa)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) tensMap >>= integer\n _ -> Nothing\n }\n\ncentsMap :: HashMap Text Integer\ncentsMap = HashMap.fromList\n [ ( \"cem\" , 100 )\n , ( \"cento\" , 100 )\n , ( \"duzentos\" , 200 )\n , ( \"trezentos\" , 300 )\n , ( \"quatrocentos\" , 400 )\n , ( \"quinhetos\" , 500 )\n , ( \"seiscentos\" , 600 )\n , ( \"setecentos\" , 700 )\n , ( \"oitocentos\" , 800 )\n , ( \"novecentos\" , 900 )\n ]\n\nruleCent :: Rule\nruleCent = Rule\n { name = \"hundreds (100..900)\"\n , pattern =\n [ regex \"(cem|cento|duzentos|trezentos|quatrocentos|quinhetos|seiscentos|setecentos|oitocentos|novecentos)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) centsMap >>= integer\n _ -> Nothing\n }\n\nrulePowersOfTen :: Rule\nrulePowersOfTen = Rule\n { name = \"powers of tens\"\n , pattern =\n [ regex \"(milhao|milh\u00c3\u00a3o|milh\u00c3\u00b5es|milhoes|bilhao|bilh\u00c3\u00a3o|bilh\u00c3\u00b5es|bilhoes|mil)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of\n \"mil\" -> double 1e3 >>= withGrain 3 >>= withMultipliable\n \"milhao\" -> double 1e6 >>= withGrain 6 >>= withMultipliable\n \"milh\u00c3\u00a3o\" -> double 1e6 >>= withGrain 6 >>= withMultipliable\n \"milh\u00c3\u00b5es\" -> double 1e6 >>= withGrain 6 >>= withMultipliable\n \"milhoes\" -> double 1e6 >>= withGrain 6 >>= withMultipliable\n \"bilhao\" -> double 1e9 >>= withGrain 9 >>= withMultipliable\n \"bilh\u00c3\u00a3o\" -> double 1e9 >>= withGrain 9 >>= withMultipliable\n \"bilh\u00c3\u00b5es\" -> double 1e9 >>= withGrain 9 >>= withMultipliable\n \"bilhoes\" -> double 1e9 >>= withGrain 9 >>= withMultipliable\n _ -> Nothing\n _ -> Nothing\n }\n\nruleCompositeTens :: Rule\nruleCompositeTens = Rule\n { name = \"integer 21..99\"\n , pattern =\n [ oneOf [20,30..90]\n , Predicate $ numberBetween 1 10\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = tens}:\n Token Numeral NumeralData{TNumeral.value = units}:\n _) -> double $ tens + units\n _ -> Nothing\n }\n\nruleDecsAnd :: Rule\nruleDecsAnd = Rule\n { name = \"number (21..29 31..39 .. 91..99)\"\n , pattern =\n [ oneOf [20, 30..90]\n , regex \"e\"\n , Predicate $ numberBetween 1 10\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v1}:\n _:\n Token Numeral NumeralData{TNumeral.value = v2}:\n _) -> double $ v1 + v2\n _ -> Nothing\n }\n\nruleCompositeCents :: Rule\nruleCompositeCents = Rule\n { name = \"integer 101..999\"\n , pattern =\n [ oneOf [100, 200..900]\n , Predicate $ numberBetween 1 100\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = hundreds}:\n Token Numeral NumeralData{TNumeral.value = units}:\n _) -> double $ hundreds + units\n _ -> Nothing\n }\n\nruleCentsAnd :: Rule\nruleCentsAnd = Rule\n { name = \"number (101..199 201..299 .. 901..999)\"\n , pattern =\n [ oneOf [100, 200..900]\n , regex \"e\"\n , Predicate $ numberBetween 1 100\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v1}:\n _:\n Token Numeral NumeralData{TNumeral.value = v2}:\n _) -> double $ v1 + v2\n _ -> Nothing\n }\n\nruleSkipHundreds :: Rule\nruleSkipHundreds = Rule\n { name = \"one twenty two\"\n , pattern =\n [ Predicate $ numberBetween 1 10\n , Predicate $ numberBetween 10 100\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = hundreds}:\n Token Numeral NumeralData{TNumeral.value = rest}:\n _) -> double $ hundreds*100 + rest\n _ -> Nothing\n }\n\nruleDotSpelledOut :: Rule\nruleDotSpelledOut = Rule\n { name = \"one point 2\"\n , pattern =\n [ dimension Numeral\n , regex \"ponto\"\n , Predicate $ not . hasGrain\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral nd1:_:Token Numeral nd2:_) ->\n double $ TNumeral.value nd1 + decimalsToDouble (TNumeral.value nd2)\n _ -> Nothing\n }\n\nruleLeadingDotSpelledOut :: Rule\nruleLeadingDotSpelledOut = Rule\n { name = \"point 77\"\n , pattern =\n [ regex \"ponto\"\n , Predicate $ not . hasGrain\n ]\n , prod = \\tokens -> case tokens of\n (_:Token Numeral nd:_) -> double . decimalsToDouble $ TNumeral.value nd\n _ -> Nothing\n }\n\nruleDecimals :: Rule\nruleDecimals = Rule\n { name = \"decimal number\"\n , pattern =\n [ regex \"(\\\\d*\\\\,\\\\d+)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> parseDecimal False match\n _ -> Nothing\n }\n\nruleCommas :: Rule\nruleCommas = Rule\n { name = \"dot-separated numbers\"\n , pattern =\n [ regex \"(\\\\d+(\\\\.\\\\d\\\\d\\\\d)+(\\\\,\\\\d+)?)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n parseDecimal False $ Text.replace \".\" Text.empty match\n _ -> Nothing\n }\n\nruleSuffixes :: Rule\nruleSuffixes = Rule\n { name = \"suffixes (K,M,G))\"\n , pattern =\n [ dimension Numeral\n , regex \"(k|m|g)(?=[\\\\W$\u00e2\u201a\u00ac\u00c2\u00a2\u00c2\u00a3]|$)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v}:\n Token RegexMatch (GroupMatch (match:_)):\n _) -> case Text.toLower match of\n \"k\" -> double $ v * 1e3\n \"m\" -> double $ v * 1e6\n \"g\" -> double $ v * 1e9\n _ -> Nothing\n _ -> Nothing\n }\n\nruleNegative :: Rule\nruleNegative = Rule\n { name = \"negative numbers\"\n , pattern =\n [ regex \"(-|menos|negativo)(?!\\\\s*\\\\-)\"\n , Predicate isPositive\n ]\n , prod = \\tokens -> case tokens of\n (_:Token Numeral nd:_) -> double $ TNumeral.value nd * (-1)\n _ -> Nothing\n }\n\nruleSum :: Rule\nruleSum = Rule\n { name = \"intersect 2 numbers\"\n , pattern =\n [ Predicate hasGrain\n , Predicate $ and . sequence [not . isMultipliable, isPositive]\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = val1, TNumeral.grain = Just g}:\n Token Numeral NumeralData{TNumeral.value = val2}:\n _) | (10 ** fromIntegral g) > val2 -> double $ val1 + val2\n _ -> Nothing\n }\n\nruleSumAnd :: Rule\nruleSumAnd = Rule\n { name = \"intersect 2 numbers (with and)\"\n , pattern =\n [ Predicate hasGrain\n , regex \"e\"\n , Predicate $ and . sequence [not . isMultipliable, isPositive]\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = val1, TNumeral.grain = Just g}:\n _:\n Token Numeral NumeralData{TNumeral.value = val2}:\n _) | (10 ** fromIntegral g) > val2 -> double $ val1 + val2\n _ -> Nothing\n }\n\nruleMultiply :: Rule\nruleMultiply = Rule\n { name = \"compose by multiplication\"\n , pattern =\n [ dimension Numeral\n , Predicate isMultipliable\n ]\n , prod = \\tokens -> case tokens of\n (token1:token2:_) -> multiply token1 token2\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleToNineteen\n , ruleTens\n , ruleCent\n , rulePowersOfTen\n , ruleCompositeTens\n , ruleCompositeCents\n , ruleSkipHundreds\n , ruleDotSpelledOut\n , ruleLeadingDotSpelledOut\n , ruleDecimals\n , ruleCommas\n , ruleSuffixes\n , ruleNegative\n , ruleSum\n , ruleDecsAnd\n , ruleCentsAnd\n , ruleSumAnd\n , ruleMultiply\n , ruleDozen\n ]\n", "num_lines": 388} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Numeral.RO.Corpus\n ( corpus\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Locale\nimport Duckling.Numeral.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncontext :: Context\ncontext = testContext {locale = makeLocale RO Nothing}\n\ncorpus :: Corpus\ncorpus = (context, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (NumeralValue 0)\n [ \"0\"\n , \"zero\"\n , \"nici unul\"\n , \"nici unu\"\n , \"nici una\"\n , \"nici o\"\n , \"nicio\"\n , \"nimic\"\n ]\n , examples (NumeralValue 1)\n [ \"1\"\n , \"unu\"\n , \"unul\"\n , \"un\"\n , \"o\"\n , \"intai\"\n , \"\u00c3\u00aent\u00c3\u00a2i\"\n ]\n , examples (NumeralValue 2)\n [ \"2\"\n , \"doi\"\n , \"doua\"\n , \"dou\u00c4\u0192\"\n ]\n , examples (NumeralValue 3)\n [ \"3\"\n , \"trei\"\n ]\n , examples (NumeralValue 4)\n [ \"4\"\n , \"patru\"\n ]\n , examples (NumeralValue 5)\n [ \"5\"\n , \"cinci\"\n ]\n , examples (NumeralValue 6)\n [ \"6\"\n , \"sase\"\n , \"\u00c8\u2122ase\"\n ]\n , examples (NumeralValue 7)\n [ \"7\"\n , \"sapte\"\n , \"\u00c8\u2122apte\"\n ]\n , examples (NumeralValue 8)\n [ \"8\"\n , \"opt\"\n ]\n , examples (NumeralValue 9)\n [ \"9\"\n , \"noua\"\n , \"nou\u00c4\u0192\"\n ]\n , examples (NumeralValue 10)\n [ \"10\"\n , \"zece\"\n , \"zeci\"\n ]\n , examples (NumeralValue 10)\n [ \"10\"\n , \"zece\"\n ]\n , examples (NumeralValue 11)\n [ \"11\"\n , \"unsprezece\"\n , \"unspe\"\n , \"un\u00c8\u2122pe\"\n ]\n , examples (NumeralValue 19)\n [ \"19\"\n , \"nouasprezece\"\n , \"nouaspe\"\n , \"nou\u00c4\u0192sprezece\"\n , \"nou\u00c4\u0192\u00c8\u2122pe\"\n ]\n , examples (NumeralValue 70)\n [ \"70\"\n , \"sapte zeci\"\n , \"\u00c8\u2122apte zeci\"\n ]\n , examples (NumeralValue 1.1)\n [ \"1,1\"\n , \"1,10\"\n , \"01,10\"\n ]\n , examples (NumeralValue 0.77)\n [ \"0,77\"\n , \",77\"\n ]\n , examples (NumeralValue 100000)\n [ \"100.000\"\n , \"100000\"\n ]\n , examples (NumeralValue 3000000)\n [ \"3000000\"\n , \"3.000.000\"\n ]\n , examples (NumeralValue 1200000)\n [ \"1.200.000\"\n , \"1200000\"\n ]\n , examples (NumeralValue (-1200000))\n [ \"-1.200.000\"\n , \"-1200000\"\n , \"minus 1.200.000\"\n ]\n , examples (NumeralValue (-3))\n [ \"-3\"\n , \"3 negativ\"\n ]\n , examples (NumeralValue 5000)\n [ \"5 mii\"\n , \"cinci mii\"\n ]\n , examples (NumeralValue 1000)\n [ \"o mie\"\n , \"1 mie\"\n ]\n , examples (NumeralValue 100)\n [ \"o suta\"\n , \"o sut\u00c4\u0192\"\n , \"1 suta\"\n , \"1 sut\u00c4\u0192\"\n ]\n , examples (NumeralValue 300)\n [ \"3 sute\"\n , \"trei sute\"\n ]\n , examples (NumeralValue 1000000)\n [ \"un milion\"\n , \"1 milion\"\n ]\n , examples (NumeralValue 7000000)\n [ \"7 milioane\"\n , \"sapte milioane\"\n , \"\u00c8\u2122apte milioane\"\n ]\n , examples (NumeralValue 21000000)\n [ \"21 de milioane\"\n , \"douazeci si unu de milioane\"\n ]\n , examples (NumeralValue 1000000000)\n [ \"un miliard\"\n , \"1 miliard\"\n ]\n , examples (NumeralValue 9000000000)\n [ \"9 miliarde\"\n , \"noua miliarde\"\n , \"nou\u00c4\u0192 miliarde\"\n ]\n , examples (NumeralValue 20)\n [ \"20\"\n , \"douazeci\"\n , \"doua zeci\"\n , \"dou\u00c4\u0192zeci\"\n , \"dou\u00c4\u0192 zeci\"\n ]\n , examples (NumeralValue 23)\n [ \"23\"\n , \"20 3\"\n , \"douazeci 3\"\n , \"dou\u00c4\u0192zeci 3\"\n , \"dou\u00c4\u0192zeci trei\"\n , \"douazeci si trei\"\n , \"dou\u00c4\u0192zeci \u00c8\u2122i trei\"\n ]\n ]\n", "num_lines": 200} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Numeral.RO.Rules\n ( rules\n ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport Data.Maybe\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers\nimport Duckling.Numeral.Types (NumeralData(..))\nimport Duckling.Regex.Types\nimport Duckling.Types\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleNumeralsPrefixWithOrMinus :: Rule\nruleNumeralsPrefixWithOrMinus = Rule\n { name = \"numbers prefix with - or minus\"\n , pattern =\n [ regex \"-|minus\"\n , Predicate isPositive\n ]\n , prod = \\case\n (_:Token Numeral nd:_) -> double (TNumeral.value nd * (-1))\n _ -> Nothing\n }\n\nruleDecimalWithThousandsSeparator :: Rule\nruleDecimalWithThousandsSeparator = Rule\n { name = \"decimal with thousands separator\"\n , pattern =\n [ regex \"(\\\\d+(\\\\.\\\\d\\\\d\\\\d)+,\\\\d+)\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):\n _) -> let fmt = Text.replace \",\" \".\" $ Text.replace \".\" Text.empty match\n in parseDouble fmt >>= double\n _ -> Nothing\n }\n\nruleDecimalNumeral :: Rule\nruleDecimalNumeral = Rule\n { name = \"decimal number\"\n , pattern =\n [ regex \"(\\\\d*,\\\\d+)\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):_) -> parseDecimal False match\n _ -> Nothing\n }\n\nruleInteger3 :: Rule\nruleInteger3 = Rule\n { name = \"integer 21..99\"\n , pattern =\n [ oneOf [20, 30 .. 90]\n , Predicate $ numberBetween 1 10\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = v1}:\n Token Numeral NumeralData{TNumeral.value = v2}:\n _) -> double $ v1 + v2\n _ -> Nothing\n }\n\nruleMultiply :: Rule\nruleMultiply = Rule\n { name = \"compose by multiplication\"\n , pattern =\n [ dimension Numeral\n , Predicate isMultipliable\n ]\n , prod = \\case\n (token1:token2:_) -> multiply token1 token2\n _ -> Nothing\n }\n\nruleMultiplyDe :: Rule\nruleMultiplyDe = Rule\n { name = \"compose by multiplication\"\n , pattern =\n [ numberWith TNumeral.value (>= 20)\n , regex \"de\"\n , Predicate isMultipliable\n ]\n , prod = \\case\n (token1:_:token2:_) -> multiply token1 token2\n _ -> Nothing\n }\n\nruleIntersect :: Rule\nruleIntersect = Rule\n { name = \"intersect\"\n , pattern =\n [ Predicate hasGrain\n , Predicate $ and . sequence [not . isMultipliable, isPositive]\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = val1, TNumeral.grain = Just g}:\n Token Numeral NumeralData{TNumeral.value = val2}:\n _) | (10 ** fromIntegral g) > val2 -> double $ val1 + val2\n _ -> Nothing\n }\n\nruleIntersectCuI :: Rule\nruleIntersectCuI = Rule\n { name = \"intersect (cu \u00c8\u2122i)\"\n , pattern =\n [ Predicate hasGrain\n , regex \"[s\u00c8\u2122]i\"\n , Predicate $ and . sequence [not . isMultipliable, isPositive]\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = val1, TNumeral.grain = Just g}:\n _:\n Token Numeral NumeralData{TNumeral.value = val2}:\n _) | (10 ** fromIntegral g) > val2 -> double $ val1 + val2\n _ -> Nothing\n }\n\nruleNumeralsSuffixesWithNegativ :: Rule\nruleNumeralsSuffixesWithNegativ = Rule\n { name = \"numbers suffixes with (negativ)\"\n , pattern =\n [ Predicate isPositive\n , regex \"neg(ativ)?\"\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = v}:\n _) -> double $ v * (-1)\n _ -> Nothing\n }\n\nrulePowersOfTen :: Rule\nrulePowersOfTen = Rule\n { name = \"powers of tens\"\n , pattern =\n [ regex \"(sut(a|e|\u00c4\u0192)?|milio(n|ane)?|miliar(de?)?|mi[ei]?)\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of\n \"suta\" -> double 1e2 >>= withGrain 2 >>= withMultipliable\n \"sute\" -> double 1e2 >>= withGrain 2 >>= withMultipliable\n \"sut\u00c4\u0192\" -> double 1e2 >>= withGrain 2 >>= withMultipliable\n \"mi\" -> double 1e3 >>= withGrain 3 >>= withMultipliable\n \"mie\" -> double 1e3 >>= withGrain 3 >>= withMultipliable\n \"mii\" -> double 1e3 >>= withGrain 3 >>= withMultipliable\n \"milio\" -> double 1e6 >>= withGrain 6 >>= withMultipliable\n \"milion\" -> double 1e6 >>= withGrain 6 >>= withMultipliable\n \"milioane\" -> double 1e6 >>= withGrain 6 >>= withMultipliable\n \"miliar\" -> double 1e9 >>= withGrain 9 >>= withMultipliable\n \"miliard\" -> double 1e9 >>= withGrain 9 >>= withMultipliable\n \"miliarde\" -> double 1e9 >>= withGrain 9 >>= withMultipliable\n _ -> Nothing\n _ -> Nothing\n }\n\nzeroTenMap :: HashMap Text Integer\nzeroTenMap = HashMap.fromList\n [ (\"zero\", 0)\n , (\"nimic\", 0)\n , (\"nicio\", 0)\n , (\"nici o\", 0)\n , (\"nici una\", 0)\n , (\"nici unu\", 0)\n , (\"nici unul\", 0)\n , (\"un\", 1)\n , (\"una\", 1)\n , (\"unu\", 1)\n , (\"unul\", 1)\n , (\"intai\", 1)\n , (\"\u00c3\u00aentai\", 1)\n , (\"int\u00c3\u00a2i\", 1)\n , (\"\u00c3\u00aent\u00c3\u00a2i\", 1)\n , (\"o\", 1)\n , (\"doi\", 2)\n , (\"doua\", 2)\n , (\"dou\u00c4\u0192\", 2)\n , (\"trei\", 3)\n , (\"patru\", 4)\n , (\"cinci\", 5)\n , (\"sase\", 6)\n , (\"\\537ase\", 6)\n , (\"sapte\", 7)\n , (\"\\537apte\", 7)\n , (\"opt\", 8)\n , (\"noua\", 9)\n , (\"nou\u00c4\u0192\", 9)\n , (\"zece\", 10)\n , (\"zeci\", 10)\n ]\n\nruleIntegerZeroTen :: Rule\nruleIntegerZeroTen = Rule\n { name = \"integer (0..10)\"\n , pattern =\n [ regex \"(zero|nimic|nici(\\\\s?o|\\\\sun(a|ul?))|una|unul?|doi|dou(a|\u00c4\u0192)|trei|patru|cinci|(s|\u00c8\u2122)ase|(s|\u00c8\u2122)apte|opt|nou(a|\u00c4\u0192)|zec[ei]|(i|\u00c3\u00ae)nt(a|\u00c3\u00a2)i|un|o)\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) zeroTenMap >>= integer\n _ -> Nothing\n }\n\nelevenNineteenMap :: HashMap Text Integer\nelevenNineteenMap = HashMap.fromList\n [ (\"un\", 11)\n , (\"doi\", 12)\n , (\"trei\", 13)\n , (\"pai\", 14)\n , (\"cin\", 15)\n , (\"cinci\", 15)\n , (\"sai\", 16)\n , (\"\\537ai\", 16)\n , (\"sapti\", 17)\n , (\"\\537apti\", 17)\n , (\"sapte\", 17)\n , (\"\\537apte\", 17)\n , (\"opti\", 18)\n , (\"opt\", 18)\n , (\"noua\", 19)\n , (\"nou\u00c4\u0192\", 19)\n ]\n\nruleInteger :: Rule\nruleInteger = Rule\n { name = \"integer (11..19)\"\n , pattern =\n [ regex \"(cin|sapti|opti)(s|\u00c8\u2122)pe|(cinci|(s|\u00c8\u2122)apte|opt)sprezece|(un|doi|trei|pai|(s|\u00c8\u2122)ai|nou(a|\u00c4\u0192))((s|\u00c8\u2122)pe|sprezece)\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (e1:_:e2:_:r:_)):_) -> do\n match <- case () of\n _ | not $ Text.null e1 -> Just e1\n | not $ Text.null e2 -> Just e2\n | not $ Text.null r -> Just r\n | otherwise -> Nothing\n HashMap.lookup (Text.toLower match) elevenNineteenMap >>= integer\n _ -> Nothing\n }\n\nruleInteger2 :: Rule\nruleInteger2 = Rule\n { name = \"integer (20..90)\"\n , pattern =\n [ regex \"(dou[a\u00c4\u0192]|trei|patru|cinci|[s\u00c8\u2122]ai|[s\u00c8\u2122]apte|opt|nou[a\u00c4\u0192])\\\\s?zeci\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):_) -> do\n unit <- HashMap.lookup (Text.toLower match) zeroTenMap\n integer (unit * 10) >>= withGrain 2 >>= withMultipliable\n _ -> Nothing\n }\n\nruleIntegerCuSeparatorDeMiiDot :: Rule\nruleIntegerCuSeparatorDeMiiDot = Rule\n { name = \"integer cu separator de mii dot\"\n , pattern =\n [ regex \"(\\\\d{1,3}(\\\\.\\\\d\\\\d\\\\d){1,5})\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):\n _) -> let fmt = Text.replace \".\" Text.empty match\n in parseDouble fmt >>= double\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleDecimalNumeral\n , ruleDecimalWithThousandsSeparator\n , ruleInteger\n , ruleIntegerZeroTen\n , ruleInteger2\n , ruleInteger3\n , ruleIntegerCuSeparatorDeMiiDot\n , ruleIntersect\n , ruleIntersectCuI\n , ruleMultiply\n , ruleMultiplyDe\n , ruleNumeralsPrefixWithOrMinus\n , ruleNumeralsSuffixesWithNegativ\n , rulePowersOfTen\n ]\n", "num_lines": 300} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree. An additional grant\n-- of patent rights can be found in the PATENTS file in the same directory.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Numeral.SK.Corpus\n ( corpus\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Locale\nimport Duckling.Numeral.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus =\n ( testContext {locale = makeLocale SK Nothing}\n , testOptions\n , allExamples\n )\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (NumeralValue 0)\n [ \"0\"\n , \"nula\"\n ]\n , examples (NumeralValue 1)\n [ \"1\"\n , \"jeden\"\n , \"jedna\"\n ]\n , examples (NumeralValue 2)\n [ \"2\"\n , \"dva\"\n , \"dve\"\n ]\n , examples (NumeralValue 7)\n [ \"7\"\n , \"sedem\"\n ]\n , examples (NumeralValue 14)\n [ \"14\"\n , \"\u00c5\u00a1trn\u00c3\u00a1s\u00c5\u00a5\"\n ]\n , examples (NumeralValue 16)\n [ \"16\"\n , \"\u00c5\u00a1estn\u00c3\u00a1s\u00c5\u00a5\"\n ]\n , examples (NumeralValue 17)\n [ \"17\"\n , \"sedemn\u00c3\u00a1s\u00c5\u00a5\"\n ]\n , examples (NumeralValue 18)\n [ \"18\"\n , \"osemn\u00c3\u00a1s\u00c5\u00a5\"\n ]\n , examples (NumeralValue 20)\n [ \"20\"\n , \"dvadsa\u00c5\u00a5\"\n ]\n , examples (NumeralValue 1.1)\n [ \"1,1\"\n , \"1,10\"\n , \"01,10\"\n ]\n , examples (NumeralValue 0.77)\n [ \"0,77\"\n , \",77\"\n ]\n , examples (NumeralValue 100000)\n [ \"100.000\"\n , \"100000\"\n , \"100K\"\n , \"100k\"\n ]\n , examples (NumeralValue 3000000)\n [ \"3M\"\n , \"3000K\"\n , \"3000000\"\n , \"3.000.000\"\n ]\n , examples (NumeralValue 1200000)\n [ \"1.200.000\"\n , \"1200000\"\n , \"1,2M\"\n , \"1200K\"\n , \",0012G\"\n ]\n , examples (NumeralValue (-1200000))\n [ \"- 1.200.000\"\n , \"-1200000\"\n , \"m\u00c3\u00adnus 1.200.000\"\n , \"-1,2M\"\n , \"-1200K\"\n , \"-,0012G\"\n ]\n , examples (NumeralValue 5000)\n [ \"5 tis\u00c3\u00adc\"\n , \"p\u00c3\u00a4\u00c5\u00a5 tis\u00c3\u00adc\"\n ]\n ]\n", "num_lines": 111} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree. An additional grant\n-- of patent rights can be found in the PATENTS file in the same directory.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Numeral.SK.Rules\n ( rules\n ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport Data.Maybe\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers\nimport Duckling.Numeral.Types (NumeralData (..))\nimport Duckling.Regex.Types\nimport Duckling.Types\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleIntersectWithAnd :: Rule\nruleIntersectWithAnd = Rule\n { name = \"intersect (with and)\"\n , pattern =\n [ Predicate hasGrain\n , regex \"a\"\n , Predicate $ and . sequence [not . isMultipliable, isPositive]\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = val1, TNumeral.grain = Just g}:\n _:\n Token Numeral NumeralData{TNumeral.value = val2}:\n _) | (10 ** fromIntegral g) > val2 -> double $ val1 + val2\n _ -> Nothing\n }\n\nruleNumeralsPrefixWithNegativeOrMinus :: Rule\nruleNumeralsPrefixWithNegativeOrMinus = Rule\n { name = \"numbers prefix with -, negative or minus\"\n , pattern =\n [ regex \"-|m\u00c3\u00adnus|z\u00c3\u00a1porn\u00c3\u00a9\"\n , Predicate isPositive\n ]\n , prod = \\case\n (_:\n Token Numeral NumeralData{TNumeral.value = v}:\n _) -> double $ v * (-1)\n _ -> Nothing\n }\n\nruleFew :: Rule\nruleFew = Rule\n { name = \"few\"\n , pattern =\n [ regex \"(zo)?p\u00c3\u00a1r\"\n ]\n , prod = \\_ -> integer 3\n }\n\nruleDecimalWithThousandsSeparator :: Rule\nruleDecimalWithThousandsSeparator = Rule\n { name = \"decimal with thousands separator\"\n , pattern =\n [ regex \"(\\\\d+(\\\\.\\\\d\\\\d\\\\d)+\\\\,\\\\d+)\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):\n _) -> let fmt = Text.replace \",\" \".\" $ Text.replace \".\" Text.empty match\n in parseDouble fmt >>= double\n _ -> Nothing\n }\n\nruleDecimalNumeral :: Rule\nruleDecimalNumeral = Rule\n { name = \"decimal number\"\n , pattern =\n [ regex \"(\\\\d*,\\\\d+)\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):\n _) -> parseDecimal False match\n _ -> Nothing\n }\n\nruleIntegerCompositeTens :: Rule\nruleIntegerCompositeTens = Rule\n { name = \"integer 21..99\"\n , pattern =\n [ oneOf [20, 30..90]\n , Predicate $ numberBetween 1 10\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = tens}:\n Token Numeral NumeralData{TNumeral.value = units}:\n _) -> double $ tens + units\n _ -> Nothing\n }\n\nruleSingle :: Rule\nruleSingle = Rule\n { name = \"single\"\n , pattern =\n [ regex \"jed(en|no|na)\"\n ]\n , prod = \\_ -> integer 1 >>= withGrain 1\n }\n\nruleSum :: Rule\nruleSum = Rule\n { name = \"intersect\"\n , pattern =\n [ Predicate hasGrain\n , Predicate $ and . sequence [not . isMultipliable, isPositive]\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = val1, TNumeral.grain = Just g}:\n Token Numeral NumeralData{TNumeral.value = val2}:\n _) | (10 ** fromIntegral g) > val2 -> double $ val1 + val2\n _ -> Nothing\n }\n\nruleMultiply :: Rule\nruleMultiply = Rule\n { name = \"compose by multiplication\"\n , pattern =\n [ dimension Numeral\n , Predicate isMultipliable\n ]\n , prod = \\case\n (token1:token2:_) -> multiply token1 token2\n _ -> Nothing\n }\n\nruleNumeralsSuffixesKMG :: Rule\nruleNumeralsSuffixesKMG = Rule\n { name = \"numbers suffixes (K, M, G)\"\n , pattern =\n [ dimension Numeral\n , regex \"([kmg])(?=[\\\\W\\\\$\u00e2\u201a\u00ac]|$)\"\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = v}:\n Token RegexMatch (GroupMatch (match:_)):\n _) -> case Text.toLower match of\n \"k\" -> double $ v * 1e3\n \"m\" -> double $ v * 1e6\n \"g\" -> double $ v * 1e9\n _ -> Nothing\n _ -> Nothing\n }\n\nrulePowersOfTen :: Rule\nrulePowersOfTen = Rule\n { name = \"powers of tens\"\n , pattern =\n [ regex \"(sto(vky)?|tis\u00c3\u00adce?|mili\u00c3\u00b3ny?)\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of\n \"sto\" -> double 1e2 >>= withGrain 2 >>= withMultipliable\n \"stovky\" -> double 1e2 >>= withGrain 2 >>= withMultipliable\n \"tis\u00c3\u00adc\" -> double 1e3 >>= withGrain 3 >>= withMultipliable\n \"tis\u00c3\u00adce\" -> double 1e3 >>= withGrain 3 >>= withMultipliable\n \"mili\u00c3\u00b3n\" -> double 1e6 >>= withGrain 6 >>= withMultipliable\n \"mili\u00c3\u00b3ny\" -> double 1e6 >>= withGrain 6 >>= withMultipliable\n _ -> Nothing\n _ -> Nothing\n }\n\nruleCouple :: Rule\nruleCouple = Rule\n { name = \"couple, a pair\"\n , pattern =\n [ regex \"p\u00c3\u00a1ry?\"\n ]\n , prod = \\_ -> integer 2\n }\n\nruleDozen :: Rule\nruleDozen = Rule\n { name = \"dozen\"\n , pattern =\n [ regex \"tucet\"\n ]\n , prod = \\_ -> integer 12 >>= withGrain 1 >>= withMultipliable\n }\n\nzeroToNineteenMap :: HashMap Text Integer\nzeroToNineteenMap = HashMap.fromList\n [ ( \"nula\" , 0 )\n , ( \"jeden\" , 1 )\n , ( \"jedna\" , 1 )\n , ( \"jedno\" , 1 )\n , ( \"dva\" , 2 )\n , ( \"dve\" , 2 )\n , ( \"tri\" , 3 )\n , ( \"\u00c5\u00a1tyri\" , 4 )\n , ( \"p\u00c3\u00a4\u00c5\u00a5\" , 5 )\n , ( \"\u00c5\u00a1es\u00c5\u00a5\" , 6 )\n , ( \"sedem\" , 7 )\n , ( \"osem\" , 8 )\n , ( \"dev\u00c3\u00a4\u00c5\u00a5\" , 9 )\n , ( \"desa\u00c5\u00a5\" , 10 )\n , ( \"jeden\u00c3\u00a1s\u00c5\u00a5\", 11 )\n , ( \"dvan\u00c3\u00a1s\u00c5\u00a5\" , 12 )\n , ( \"trin\u00c3\u00a1s\u00c5\u00a5\" , 13 )\n , ( \"\u00c5\u00a1trn\u00c3\u00a1s\u00c5\u00a5\" , 14 )\n , ( \"p\u00c3\u00a4tn\u00c3\u00a1s\u00c5\u00a5\" , 15 )\n , ( \"\u00c5\u00a1estn\u00c3\u00a1s\u00c5\u00a5\", 16 )\n , ( \"sedemn\u00c3\u00a1s\u00c5\u00a5\", 17 )\n , ( \"osemn\u00c3\u00a1s\u00c5\u00a5\" , 18 )\n , ( \"dev\u00c3\u00a4tn\u00c3\u00a1s\u00c5\u00a5\", 19 )\n ]\n\nruleInteger :: Rule\nruleInteger = Rule\n { name = \"integer (0..19)\"\n -- e.g. jeden\u00c3\u00a1s\u00c5\u00a5 must be before jeden, otherwise jeden will always shadow jeden\u00c3\u00a1s\u00c5\u00a5\n , pattern =\n [ regex \"(nula|jed(en\u00c3\u00a1s\u00c5\u00a5|en|na|no)|dv(an\u00c3\u00a1s\u00c5\u00a5|a|e)|trin\u00c3\u00a1s\u00c5\u00a5|tri|\u00c5\u00a1trn\u00c3\u00a1s\u00c5\u00a5|\u00c5\u00a1tyri|p\u00c3\u00a4tn\u00c3\u00a1s\u00c5\u00a5|p\u00c3\u00a4\u00c5\u00a5|\u00c5\u00a1estn\u00c3\u00a1s\u00c5\u00a5|\u00c5\u00a1es\u00c5\u00a5|sedemn\u00c3\u00a1s\u00c5\u00a5|sedem|osemn\u00c3\u00a1s\u00c5\u00a5|osem|dev\u00c3\u00a4tn\u00c3\u00a1s\u00c5\u00a5|dev\u00c3\u00a4\u00c5\u00a5|desa\u00c5\u00a5)\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) zeroToNineteenMap >>= integer\n _ -> Nothing\n }\n\ndozenMap :: HashMap Text Integer\ndozenMap = HashMap.fromList\n [ ( \"dvadsa\u00c5\u00a5\" , 20)\n , ( \"tridsa\u00c5\u00a5\" , 30)\n , ( \"\u00c5\u00a1tyridsa\u00c5\u00a5\" , 40)\n , ( \"p\u00c3\u00a4\u00c5\u00a5desiat\" , 50)\n , ( \"\u00c5\u00a1es\u00c5\u00a5desiat\" , 60)\n , ( \"sedemdesiat\" , 70)\n , ( \"osemdesiat\" , 80)\n , ( \"dev\u00c3\u00a4tdesiat\" , 90)\n ]\n\nruleInteger2 :: Rule\nruleInteger2 = Rule\n { name = \"integer (20..90)\"\n , pattern =\n [ regex \"((dva|tri|\u00c5\u00a1tyri)dsa\u00c5\u00a5|(p\u00c3\u00a4\u00c5\u00a5|\u00c5\u00a1es\u00c5\u00a5|sedem|osem|dev\u00c3\u00a4t)desiat)\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) dozenMap >>= integer\n _ -> Nothing\n }\n\nruleNumeralDotNumeral :: Rule\nruleNumeralDotNumeral = Rule\n { name = \"number dot number\"\n , pattern =\n [ dimension Numeral\n , regex \"cel\u00c3\u00a1|cel\u00c3\u00bdch|cel\u00c3\u00a9\"\n , Predicate $ not . hasGrain\n ]\n , prod = \\case\n (Token Numeral nd1:_:Token Numeral nd2:_) ->\n double $ TNumeral.value nd1 + decimalsToDouble (TNumeral.value nd2)\n _ -> Nothing\n }\n\nruleIntegerWithThousandsSeparator :: Rule\nruleIntegerWithThousandsSeparator = Rule\n { name = \"integer with thousands separator .\"\n , pattern =\n [ regex \"(\\\\d{1,3}(\\\\.\\\\d\\\\d\\\\d){1,5})\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):\n _) -> let fmt = Text.replace \".\" Text.empty match\n in parseDouble fmt >>= double\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleCouple\n , ruleDecimalNumeral\n , ruleDecimalWithThousandsSeparator\n , ruleDozen\n , ruleFew\n , ruleInteger\n , ruleInteger2\n , ruleIntegerCompositeTens\n , ruleIntegerWithThousandsSeparator\n , ruleSum\n , ruleIntersectWithAnd\n , ruleMultiply\n , ruleNumeralDotNumeral\n , ruleNumeralsPrefixWithNegativeOrMinus\n , ruleNumeralsSuffixesKMG\n , rulePowersOfTen\n , ruleSingle\n ]\n", "num_lines": 310} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Numeral.SV.Corpus\n ( corpus ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Locale\nimport Duckling.Numeral.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale SV Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (NumeralValue 0)\n [ \"0\"\n , \"noll\"\n ]\n , examples (NumeralValue 1)\n [ \"1\"\n , \"en\"\n , \"ett\"\n ]\n , examples (NumeralValue 2)\n [ \"2\"\n , \"tv\u00c3\u00a5\"\n , \"ett par\"\n ]\n , examples (NumeralValue 7)\n [ \"7\"\n , \"sju\"\n ]\n , examples (NumeralValue 14)\n [ \"14\"\n , \"Fjorton\"\n ]\n , examples (NumeralValue 16)\n [ \"16\"\n , \"sexton\"\n ]\n , examples (NumeralValue 17)\n [ \"17\"\n , \"sjutton\"\n ]\n , examples (NumeralValue 18)\n [ \"18\"\n , \"arton\"\n ]\n , examples (NumeralValue 20)\n [ \"20\"\n , \"tjugo\"\n ]\n , examples (NumeralValue 1.1)\n [ \"1,1\"\n , \"1,10\"\n , \"01,10\"\n ]\n , examples (NumeralValue 0.77)\n [ \"0,77\"\n , \",77\"\n ]\n , examples (NumeralValue 100000)\n [ \"100.000\"\n , \"100000\"\n , \"100K\"\n , \"100k\"\n ]\n , examples (NumeralValue 3000000)\n [ \"3M\"\n , \"3000K\"\n , \"3000000\"\n , \"3.000.000\"\n ]\n , examples (NumeralValue 1200000)\n [ \"1.200.000\"\n , \"1200000\"\n , \"1,2M\"\n , \"1200K\"\n , \",0012G\"\n ]\n , examples (NumeralValue (-1200000))\n [ \"- 1.200.000\"\n , \"-1200000\"\n , \"minus 1.200.000\"\n , \"negativ 1200000\"\n , \"-1,2M\"\n , \"-1200K\"\n , \"-,0012G\"\n ]\n , examples (NumeralValue 5000)\n [ \"5 tusen\"\n , \"fem tusen\"\n ]\n ]\n", "num_lines": 106} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Numeral.SV.Rules\n ( rules\n ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport Data.Maybe\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers\nimport Duckling.Numeral.Types (NumeralData (..))\nimport Duckling.Regex.Types\nimport Duckling.Types\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleIntersectWithAnd :: Rule\nruleIntersectWithAnd = Rule\n { name = \"intersect (with and)\"\n , pattern =\n [ Predicate hasGrain\n , regex \"och\"\n , Predicate $ and . sequence [not . isMultipliable, isPositive]\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = val1, TNumeral.grain = Just g}:\n _:\n Token Numeral NumeralData{TNumeral.value = val2}:\n _) | (10 ** fromIntegral g) > val2 -> double $ val1 + val2\n _ -> Nothing\n }\n\nruleNumeralsPrefixWithNegativeOrMinus :: Rule\nruleNumeralsPrefixWithNegativeOrMinus = Rule\n { name = \"numbers prefix with -, negative or minus\"\n , pattern =\n [ regex \"-|minus|negativ\"\n , Predicate isPositive\n ]\n , prod = \\tokens -> case tokens of\n (_:\n Token Numeral NumeralData{TNumeral.value = v}:\n _) -> double $ v * (-1)\n _ -> Nothing\n }\n\nruleFew :: Rule\nruleFew = Rule\n { name = \"few\"\n , pattern =\n [ regex \"(n\u00c3\u00a5gra )?f\u00c3\u00a5\"\n ]\n , prod = \\_ -> integer 3\n }\n\nruleDecimalWithThousandsSeparator :: Rule\nruleDecimalWithThousandsSeparator = Rule\n { name = \"decimal with thousands separator\"\n , pattern =\n [ regex \"(\\\\d+(\\\\.\\\\d\\\\d\\\\d)+\\\\,\\\\d+)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):\n _) -> let fmt = Text.replace \",\" \".\" $ Text.replace \".\" Text.empty match\n in parseDouble fmt >>= double\n _ -> Nothing\n }\n\nruleDecimalNumeral :: Rule\nruleDecimalNumeral = Rule\n { name = \"decimal number\"\n , pattern =\n [ regex \"(\\\\d*,\\\\d+)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):\n _) -> parseDecimal False match\n _ -> Nothing\n }\n\nruleInteger3 :: Rule\nruleInteger3 = Rule\n { name = \"integer 21..99\"\n , pattern =\n [ oneOf [70, 20, 60, 50, 40, 90, 30, 80]\n , Predicate $ numberBetween 1 10\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v1}:\n Token Numeral NumeralData{TNumeral.value = v2}:\n _) -> double $ v1 + v2\n _ -> Nothing\n }\n\nruleSingle :: Rule\nruleSingle = Rule\n { name = \"single\"\n , pattern =\n [ regex \"enkel\"\n ]\n , prod = \\_ -> integer 1 >>= withGrain 1\n }\n\nruleIntersect :: Rule\nruleIntersect = Rule\n { name = \"intersect\"\n , pattern =\n [ Predicate hasGrain\n , Predicate $ and . sequence [not . isMultipliable, isPositive]\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = val1, TNumeral.grain = Just g}:\n Token Numeral NumeralData{TNumeral.value = val2}:\n _) | (10 ** fromIntegral g) > val2 -> double $ val1 + val2\n _ -> Nothing\n }\n\nruleMultiply :: Rule\nruleMultiply = Rule\n { name = \"compose by multiplication\"\n , pattern =\n [ dimension Numeral\n , Predicate isMultipliable\n ]\n , prod = \\tokens -> case tokens of\n (token1:token2:_) -> multiply token1 token2\n _ -> Nothing\n }\n\nruleNumeralsSuffixesKMG :: Rule\nruleNumeralsSuffixesKMG = Rule\n { name = \"numbers suffixes (K, M, G)\"\n , pattern =\n [ dimension Numeral\n , regex \"([kmg])(?=[\\\\W\\\\$\u00e2\u201a\u00ac]|$)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v}:\n Token RegexMatch (GroupMatch (match:_)):\n _) -> case Text.toLower match of\n \"k\" -> double $ v * 1e3\n \"m\" -> double $ v * 1e6\n \"g\" -> double $ v * 1e9\n _ -> Nothing\n _ -> Nothing\n }\n\nrulePowersOfTen :: Rule\nrulePowersOfTen = Rule\n { name = \"powers of tens\"\n , pattern =\n [ regex \"(hundra?|tusen?|miljon(er)?)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of\n \"hundr\" -> double 1e2 >>= withGrain 2 >>= withMultipliable\n \"hundra\" -> double 1e2 >>= withGrain 2 >>= withMultipliable\n \"tuse\" -> double 1e3 >>= withGrain 3 >>= withMultipliable\n \"tusen\" -> double 1e3 >>= withGrain 3 >>= withMultipliable\n \"miljon\" -> double 1e6 >>= withGrain 6 >>= withMultipliable\n \"miljoner\" -> double 1e6 >>= withGrain 6 >>= withMultipliable\n _ -> Nothing\n _ -> Nothing\n }\n\nruleCouple :: Rule\nruleCouple = Rule\n { name = \"couple, a pair\"\n , pattern =\n [ regex \"ett par\"\n ]\n , prod = \\_ -> integer 2\n }\n\nruleDozen :: Rule\nruleDozen = Rule\n { name = \"dozen\"\n , pattern =\n [ regex \"dussin\"\n ]\n , prod = \\_ -> integer 12 >>= withGrain 1 >>= withMultipliable\n }\n\nzeroToNineteenMap :: HashMap Text Integer\nzeroToNineteenMap = HashMap.fromList\n [ ( \"inget\" , 0 )\n , ( \"ingen\" , 0 )\n , ( \"noll\" , 0 )\n , ( \"en\" , 1 )\n , ( \"ett\" , 1 )\n , ( \"tv\u00c3\u00a5\" , 2 )\n , ( \"tre\" , 3 )\n , ( \"fyra\" , 4 )\n , ( \"fem\" , 5 )\n , ( \"sex\" , 6 )\n , ( \"sju\" , 7 )\n , ( \"\u00c3\u00a5tta\", 8 )\n , ( \"nio\" , 9 )\n , ( \"tio\" , 10 )\n , ( \"elva\" , 11 )\n , ( \"tolv\" , 12 )\n , ( \"tretton\" , 13 )\n , ( \"fjorton\" , 14 )\n , ( \"femton\" , 15 )\n , ( \"sexton\" , 16 )\n , ( \"sjutton\" , 17 )\n , ( \"arton\" , 18 )\n , ( \"nitton\" , 19 )\n ]\n\nruleInteger :: Rule\nruleInteger = Rule\n { name = \"integer (0..19)\"\n , pattern =\n [ regex \"(inget|ingen|noll|en|ett|tv\u00c3\u00a5|tretton|tre|fyra|femton|fem|sexton|sex|sjutton|sju|\u00c3\u00a5tta|nio|tio|elva|tolv|fjorton|arton|nitton)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) zeroToNineteenMap >>= integer\n _ -> Nothing\n }\n\ndozenMap :: HashMap Text Integer\ndozenMap = HashMap.fromList\n [ ( \"tjugo\" , 20)\n , ( \"trettio\" , 30)\n , ( \"fyrtio\" , 40)\n , ( \"femtio\" , 50)\n , ( \"sextio\" , 60)\n , ( \"sjuttio\" , 70)\n , ( \"\u00c3\u00a5ttio\" , 80)\n , ( \"nittio\" , 90)\n ]\n\nruleInteger2 :: Rule\nruleInteger2 = Rule\n { name = \"integer (20..90)\"\n , pattern =\n [ regex \"(tjugo|trettio|fyrtio|femtio|sextio|sjuttio|\u00c3\u00a5ttio|nittio)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) dozenMap >>= integer\n _ -> Nothing\n }\n\nruleNumeralDotNumeral :: Rule\nruleNumeralDotNumeral = Rule\n { name = \"number dot number\"\n , pattern =\n [ dimension Numeral\n , regex \"komma\"\n , Predicate $ not . hasGrain\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral nd1:_:Token Numeral nd2:_) ->\n double $ TNumeral.value nd1 + decimalsToDouble (TNumeral.value nd2)\n _ -> Nothing\n }\n\nruleIntegerWithThousandsSeparator :: Rule\nruleIntegerWithThousandsSeparator = Rule\n { name = \"integer with thousands separator .\"\n , pattern =\n [ regex \"(\\\\d{1,3}(\\\\.\\\\d\\\\d\\\\d){1,5})\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):\n _) -> let fmt = Text.replace \".\" Text.empty match\n in parseDouble fmt >>= double\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleCouple\n , ruleDecimalNumeral\n , ruleDecimalWithThousandsSeparator\n , ruleDozen\n , ruleFew\n , ruleInteger\n , ruleInteger2\n , ruleInteger3\n , ruleIntegerWithThousandsSeparator\n , ruleIntersect\n , ruleIntersectWithAnd\n , ruleMultiply\n , ruleNumeralDotNumeral\n , ruleNumeralsPrefixWithNegativeOrMinus\n , ruleNumeralsSuffixesKMG\n , rulePowersOfTen\n , ruleSingle\n ]\n", "num_lines": 307} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Numeral.SW.Corpus\n ( corpus ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Locale\nimport Duckling.Numeral.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale SW Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (NumeralValue 0)\n [ \"0\"\n , \"sufuri\"\n , \"zero\"\n ]\n , examples (NumeralValue 1)\n [ \"moja\"\n ]\n , examples (NumeralValue 2)\n [ \"mbili\"\n ]\n , examples (NumeralValue 3)\n [ \"tatu\"\n ]\n , examples (NumeralValue 4)\n [ \"nne\"\n ]\n , examples (NumeralValue 5)\n [ \"tano\"\n ]\n , examples (NumeralValue 6)\n [ \"sita\"\n ]\n , examples (NumeralValue 7)\n [ \"saba\"\n ]\n , examples (NumeralValue 8)\n [ \"nane\"\n ]\n , examples (NumeralValue 9)\n [ \"tisa\"\n ]\n , examples (NumeralValue 10)\n [ \"kumi\"\n ]\n , examples (NumeralValue 20)\n [ \"ishirini\"\n ]\n , examples (NumeralValue 30)\n [ \"thelathini\"\n ]\n , examples (NumeralValue 40)\n [ \"arubaini\"\n , \"arobaini\"\n ]\n , examples (NumeralValue 50)\n [ \"hamsini\"\n ]\n , examples (NumeralValue 60)\n [ \"sitini\"\n ]\n , examples (NumeralValue 70)\n [ \"sabini\"\n ]\n , examples (NumeralValue 80)\n [ \"themanini\"\n ]\n , examples (NumeralValue 90)\n [ \"tisini\"\n ]\n ]\n", "num_lines": 87} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n{-# LANGUAGE NoRebindableSyntax #-}\n\nmodule Duckling.Numeral.SW.Rules\n ( rules\n ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport Data.Maybe\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers\nimport Duckling.Numeral.Types (NumeralData (..))\nimport Duckling.Regex.Types\nimport Duckling.Types\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleNumeralMap :: HashMap Text Integer\nruleNumeralMap = HashMap.fromList\n [ ( \"sufuri\", 0 )\n , ( \"zero\", 0 )\n , ( \"moja\", 1 )\n , ( \"mbili\", 2 )\n , ( \"tatu\", 3 )\n , ( \"nne\", 4 )\n , ( \"tano\", 5)\n , ( \"sita\", 6)\n , ( \"saba\", 7)\n , ( \"nane\", 8)\n , ( \"tisa\", 9)\n , ( \"kumi\", 10)\n ]\n\nruleNumeral :: Rule\nruleNumeral = Rule\n { name = \"number (0..10)\"\n , pattern =\n [ regex \"(sufuri|zero|moja|mbili|tatu|nne|tano|sita|saba|nane|tisa|kumi)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) ruleNumeralMap >>= integer\n _ -> Nothing\n }\n\ntensMap :: HashMap Text Integer\ntensMap = HashMap.fromList\n [ ( \"ishirini\", 20 )\n , ( \"thelathini\", 30 )\n , ( \"arubaini\", 40 )\n , ( \"arobaini\", 40 )\n , ( \"hamsini\", 50 )\n , ( \"sitini\", 60 )\n , ( \"sabini\", 70 )\n , ( \"themanini\", 80 )\n , ( \"tisini\", 90 )\n ]\n\nruleTens :: Rule\nruleTens = Rule\n { name = \"integer (20,30..90)\"\n , pattern =\n [ regex \"(ishirini|thelathini|arubaini|arobaini|hamsini|sitini|sabini|themanini|tisini)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) tensMap >>= integer\n _ -> Nothing\n }\n\n\nruleCompositeTens :: Rule\nruleCompositeTens = Rule\n { name = \"integer 11..19 21..29 .. 91..99\"\n , pattern = [oneOf [20,30..90]\n , regex \"-?na-?\"\n , Predicate $ numberBetween 1 10]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v1}:\n Token Numeral NumeralData{TNumeral.value = v2}:\n _) -> double $ v1 + v2\n _ -> Nothing\n }\n\n\nrules :: [Rule]\nrules =\n [ ruleNumeral\n , ruleTens\n , ruleCompositeTens\n ]\n", "num_lines": 105} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Numeral.TR.Corpus\n ( corpus ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Locale\nimport Duckling.Numeral.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale TR Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (NumeralValue 0)\n [ \"0\"\n , \"yok\"\n , \"hi\u00c3\u00a7\"\n , \"s\u00c4\u00b1f\u00c4\u00b1r\"\n ]\n , examples (NumeralValue 1)\n [ \"1\"\n , \"bir\"\n , \"tek\"\n , \"yek\"\n ]\n , examples (NumeralValue 2)\n [ \"2\"\n , \"iki\"\n , \"\u00c3\u00a7ift\"\n ]\n , examples (NumeralValue 33)\n [ \"33\"\n , \"otuz\u00c3\u00bc\u00c3\u00a7\"\n , \"otuz \u00c3\u00bc\u00c3\u00a7\"\n , \"0033\"\n ]\n , examples (NumeralValue 14)\n [ \"14\"\n , \"ond\u00c3\u00b6rt\"\n , \"on d\u00c3\u00b6rt\"\n ]\n , examples (NumeralValue 16)\n [ \"16\"\n , \"onalt\u00c4\u00b1\"\n , \"on alt\u00c4\u00b1\"\n ]\n , examples (NumeralValue 17)\n [ \"17\"\n , \"onyedi\"\n , \"on yedi\"\n ]\n , examples (NumeralValue 18)\n [ \"18\"\n , \"onsekiz\"\n , \"on sekiz\"\n ]\n , examples (NumeralValue 1.1)\n [ \"1,1\"\n , \"1,10\"\n , \"01,10\"\n , \"bir virg\u00c3\u00bcl bir\"\n , \"bir nokta bir\"\n ]\n , examples (NumeralValue 0.77)\n [ \"0,77\"\n , \",77\"\n , \"s\u00c4\u00b1f\u00c4\u00b1r virg\u00c3\u00bcl yetmi\u00c5\u0178yedi\"\n , \"s\u00c4\u00b1f\u00c4\u00b1r virg\u00c3\u00bcl yetmi\u00c5\u0178 yedi\"\n ]\n , examples (NumeralValue 100000)\n [ \"100.000\"\n , \"100000\"\n , \"100K\"\n , \"100k\"\n , \"100b\"\n ]\n , examples (NumeralValue 3000000)\n [ \"3M\"\n , \"3000K\"\n , \"3000000\"\n , \"3.000.000\"\n ]\n , examples (NumeralValue 1200000)\n [ \"1.200.000\"\n , \"1200000\"\n , \"1,2M\"\n , \"1200K\"\n , \",0012G\"\n , \"1200B\"\n ]\n , examples (NumeralValue (-1200000))\n [ \"- 1.200.000\"\n , \"-1200000\"\n , \"eksi 1.200.000\"\n , \"negatif 1200000\"\n , \"-1,2M\"\n , \"-1200K\"\n , \"-,0012G\"\n , \"-1200B\"\n ]\n , examples (NumeralValue 5000)\n [ \"5 bin\"\n , \"be\u00c5\u0178 bin\"\n ]\n , examples (NumeralValue 50)\n [ \"5 deste\"\n , \"be\u00c5\u0178 deste\"\n ]\n , examples (NumeralValue 200000)\n [ \"iki y\u00c3\u00bcz bin\"\n , \"ikiy\u00c3\u00bczbin\"\n ]\n , examples (NumeralValue 21011)\n [ \"yirmi bir bin on bir\"\n , \"yirmibir bin onbir\"\n ]\n , examples (NumeralValue 721012)\n [ \"yedi y\u00c3\u00bcz yirmibir bin on iki\"\n , \"yedi y\u00c3\u00bcz yirmi bir bin on iki\"\n , \"yediy\u00c3\u00bcz yirmibir bin oniki\"\n ]\n , examples (NumeralValue 300341)\n [ \"\u00c3\u00bc\u00c3\u00a7y\u00c3\u00bczbin \u00c3\u00bc\u00c3\u00a7y\u00c3\u00bcz k\u00c4\u00b1rkbir\"\n , \"\u00c3\u00bc\u00c3\u00a7 y\u00c3\u00bcz bin \u00c3\u00bc\u00c3\u00a7 y\u00c3\u00bcz k\u00c4\u00b1rk bir\"\n ]\n , examples (NumeralValue 40348)\n [ \"k\u00c4\u00b1rkbin \u00c3\u00bc\u00c3\u00a7y\u00c3\u00bcz k\u00c4\u00b1rksekiz\"\n , \"k\u00c4\u00b1rk bin \u00c3\u00bc\u00c3\u00a7 y\u00c3\u00bcz k\u00c4\u00b1rk sekiz\"\n ]\n , examples (NumeralValue 31256721)\n [ \"otuz bir milyon iki y\u00c3\u00bcz elli alt\u00c4\u00b1 bin yedi y\u00c3\u00bcz yirmi bir\"\n ]\n , examples (NumeralValue 107)\n [ \"107\"\n , \"y\u00c3\u00bcz yedi\"\n ]\n , examples (NumeralValue 5.5)\n [ \"be\u00c5\u0178 bu\u00c3\u00a7uk\"\n , \"be\u00c5\u0178bu\u00c3\u00a7uk\"\n , \"5 bu\u00c3\u00a7uk\"\n , \"5,5\"\n ]\n , examples (NumeralValue 3500000)\n [ \"3,5 milyon\"\n , \"3500000\"\n , \"\u00c3\u00bc\u00c3\u00a7 bu\u00c3\u00a7uk milyon\"\n , \"\u00c3\u00bc\u00c3\u00a7bu\u00c3\u00a7uk milyon\"\n , \"3,5M\"\n ]\n , examples (NumeralValue 0.5)\n [ \"yar\u00c4\u00b1m\"\n , \"0,5\"\n ]\n , examples (NumeralValue 2500)\n [ \"2,5 bin\"\n , \"2500\"\n , \"iki bin be\u00c5\u0178 y\u00c3\u00bcz\"\n , \"ikibin be\u00c5\u0178y\u00c3\u00bcz\"\n ]\n , examples (NumeralValue 2200000)\n [ \"2,2 milyon\"\n , \"iki nokta iki milyon\"\n , \"iki virg\u00c3\u00bcl iki milyon\"\n ]\n , examples (NumeralValue 72.5)\n [ \"yetmi\u00c5\u0178ikibu\u00c3\u00a7uk\"\n , \"yetmi\u00c5\u0178iki bu\u00c3\u00a7uk\"\n , \"yetmi\u00c5\u0178 iki bu\u00c3\u00a7uk\"\n , \"72,5\"\n ]\n ]\n", "num_lines": 184} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Numeral.TR.Rules\n ( rules\n ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport Data.Maybe\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers\nimport Duckling.Numeral.Types (NumeralData (..))\nimport Duckling.Regex.Types\nimport Duckling.Types\nimport qualified Duckling.Numeral.Types as TNumeral\n\nhundredsMap :: HashMap Text Integer\nhundredsMap = HashMap.fromList\n [ ( \"y\u00c3\u00bcz\", 100)\n , ( \"ikiy\u00c3\u00bcz\", 200)\n , ( \"\u00c3\u00bc\u00c3\u00a7y\u00c3\u00bcz\", 300)\n , ( \"d\u00c3\u00b6rty\u00c3\u00bcz\", 400)\n , ( \"be\u00c5\u0178y\u00c3\u00bcz\", 500)\n , ( \"alt\u00c4\u00b1y\u00c3\u00bcz\", 600)\n , ( \"yediy\u00c3\u00bcz\", 700)\n , ( \"sekizy\u00c3\u00bcz\", 800)\n , ( \"dokuzy\u00c3\u00bcz\", 900)\n ]\n\n\nruleInteger5 :: Rule\nruleInteger5 = Rule\n { name = \"integer 100..900\"\n , pattern =\n [ regex \"(y\u00c3\u00bcz|ikiy\u00c3\u00bcz|\u00c3\u00bc\u00c3\u00a7y\u00c3\u00bcz|d\u00c3\u00b6rty\u00c3\u00bcz|be\u00c5\u0178y\u00c3\u00bcz|alt\u00c4\u00b1y\u00c3\u00bcz|yediy\u00c3\u00bcz|sekizy\u00c3\u00bcz|dokuzy\u00c3\u00bcz)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) hundredsMap >>= integer >>= withGrain 2\n _ -> Nothing\n }\n\nruleNumeralsPrefixWithNegativeOrMinus :: Rule\nruleNumeralsPrefixWithNegativeOrMinus = Rule\n { name = \"numbers prefix with -, negative or minus\"\n , pattern =\n [ regex \"-|eksi|negatif\"\n , Predicate isPositive\n ]\n , prod = \\tokens -> case tokens of\n (_:Token Numeral NumeralData{TNumeral.value = v}:_) ->\n double (v * (- 1))\n _ -> Nothing\n }\n\nruleACoupleOf :: Rule\nruleACoupleOf = Rule\n { name = \"a couple (of)\"\n , pattern =\n [ regex \"(bir )?\u00c3\u00a7ift\"\n ]\n , prod = \\_ -> integer 2 >>= withGrain 1\n }\n\nruleFew :: Rule\nruleFew = Rule\n { name = \"few\"\n , pattern =\n [ regex \"(bir)?az\"\n ]\n , prod = \\_ -> integer 3\n }\n\nruleTen :: Rule\nruleTen = Rule\n { name = \"ten\"\n , pattern =\n [ regex \"on\"\n ]\n , prod = \\_ -> integer 10 >>= withGrain 1 >>= withMultipliable\n }\n\nruleDecimalWithThousandsSeparator :: Rule\nruleDecimalWithThousandsSeparator = Rule\n { name = \"decimal with thousands separator\"\n , pattern =\n [ regex \"(\\\\d+(\\\\.\\\\d\\\\d\\\\d)+,\\\\d+)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):\n _) -> let fmt = Text.replace \",\" \".\" $ Text.replace \".\" Text.empty match\n in parseDouble fmt >>= double\n _ -> Nothing\n }\n\nruleMultiply :: Rule\nruleMultiply = Rule\n { name = \"compose by multiplication\"\n , pattern =\n [ dimension Numeral\n , Predicate isMultipliable\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = val1}:\n Token Numeral NumeralData{TNumeral.value = val2, TNumeral.grain = g2}:\n _) | isNothing g2 || (isJust g2 && val2 > val1) -> case g2 of\n Nothing -> double $ val1 * val2\n Just g -> double (val1 * val2) >>= withGrain g\n _ -> Nothing\n }\n\nruleDecimalNumeral :: Rule\nruleDecimalNumeral = Rule\n { name = \"decimal number\"\n , pattern =\n [ regex \"(\\\\d*,\\\\d+)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n parseDecimal False match\n _ -> Nothing\n }\n\nnumeralSuffixesHalfsuffixTextMap :: HashMap Text Double\nnumeralSuffixesHalfsuffixTextMap = HashMap.fromList\n [ ( \"birbu\u00c3\u00a7uk\", 1.5)\n , ( \"bibu\u00c3\u00a7uk\", 1.5)\n , ( \"ikibu\u00c3\u00a7uk\", 2.5)\n , ( \"\u00c3\u00bc\\231bu\u00c3\u00a7uk\", 3.5)\n , ( \"d\u00c3\u00b6rtbu\u00c3\u00a7uk\", 4.5)\n , ( \"be\\351bu\u00c3\u00a7uk\", 5.5)\n , ( \"alt\u00c4\u00b1bu\u00c3\u00a7uk\", 6.5)\n , ( \"yedibu\u00c3\u00a7uk\", 7.5)\n , ( \"sekizbu\u00c3\u00a7uk\", 8.5)\n , ( \"dokuzbu\u00c3\u00a7uk\", 9.5)\n ]\n\nruleNumeralSuffixesHalfsuffixText :: Rule\nruleNumeralSuffixesHalfsuffixText = Rule\n { name = \"number suffixes (half-suffix text) (1..9)\"\n , pattern =\n [ regex \"((bir?|iki|\u00c3\u00bc\u00c3\u00a7\u00c3\u00bc?|d\u00c3\u00b6rt|be\u00c5\u0178|alt\u00c4\u00b1|yedi|sekiz|dokuz)(bu\u00c3\u00a7uk))\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) numeralSuffixesHalfsuffixTextMap >>= double\n _ -> Nothing\n }\n\ntenToNintynineMap :: HashMap Text Integer\ntenToNintynineMap = HashMap.fromList\n [ ( \"onbi\", 11)\n , ( \"onbir\", 11)\n , ( \"oniki\", 12)\n , ( \"on\u00c3\u00bc\u00c3\u00a7\", 13)\n , ( \"ond\u00c3\u00b6rt\", 14)\n , ( \"onbe\u00c5\u0178\", 15)\n , ( \"onalt\u00c4\u00b1\", 16)\n , ( \"onyedi\", 17)\n , ( \"onsekiz\", 18)\n , ( \"ondokuz\", 19)\n , ( \"yirmibi\", 21)\n , ( \"yirmibir\", 21)\n , ( \"yirmiiki\", 22)\n , ( \"yirmi\u00c3\u00bc\u00c3\u00a7\", 23)\n , ( \"yirmid\u00c3\u00b6rt\", 24)\n , ( \"yirmibe\u00c5\u0178\", 25)\n , ( \"yirmialt\u00c4\u00b1\", 26)\n , ( \"yirmiyedi\", 27)\n , ( \"yirmisekiz\", 28)\n , ( \"yirmidokuz\", 29)\n , ( \"otuzbi\", 31)\n , ( \"otuzbir\", 31)\n , ( \"otuziki\", 32)\n , ( \"otuz\u00c3\u00bc\u00c3\u00a7\", 33)\n , ( \"otuzd\u00c3\u00b6rt\", 34)\n , ( \"otuzbe\u00c5\u0178\", 35)\n , ( \"otuzalt\u00c4\u00b1\", 36)\n , ( \"otuzyedi\", 37)\n , ( \"otuzsekiz\", 38)\n , ( \"otuzdokuz\", 39)\n , ( \"k\u00c4\u00b1rkbir\", 41)\n , ( \"k\u00c4\u00b1rkbi\", 41)\n , ( \"k\u00c4\u00b1rkiki\", 42)\n , ( \"k\u00c4\u00b1rk\u00c3\u00bc\u00c3\u00a7\", 43)\n , ( \"k\u00c4\u00b1rkd\u00c3\u00b6rt\", 44)\n , ( \"k\u00c4\u00b1rkbe\u00c5\u0178\", 45)\n , ( \"k\u00c4\u00b1rkalt\u00c4\u00b1\", 46)\n , ( \"k\u00c4\u00b1rkyedi\", 47)\n , ( \"k\u00c4\u00b1rksekiz\", 48)\n , ( \"k\u00c4\u00b1rkdokuz\", 49)\n , ( \"ellibi\", 51)\n , ( \"ellibir\", 51)\n , ( \"elliiki\", 52)\n , ( \"elli\u00c3\u00bc\u00c3\u00a7\", 53)\n , ( \"ellid\u00c3\u00b6rt\", 54)\n , ( \"ellibe\u00c5\u0178\", 55)\n , ( \"ellialt\u00c4\u00b1\", 56)\n , ( \"elliyedi\", 57)\n , ( \"ellisekiz\", 58)\n , ( \"ellidokuz\", 59)\n , ( \"altm\u00c4\u00b1\u00c5\u0178bir\", 61)\n , ( \"atm\u00c4\u00b1\u00c5\u0178bir\", 61)\n , ( \"atm\u00c4\u00b1\u00c5\u0178iki\", 62)\n , ( \"altm\u00c4\u00b1\u00c5\u0178iki\", 62)\n , ( \"atm\u00c4\u00b1\u00c5\u0178\u00c3\u00bc\u00c3\u00a7\", 63)\n , ( \"altm\u00c4\u00b1\u00c5\u0178\u00c3\u00bc\u00c3\u00a7\", 63)\n , ( \"atm\u00c4\u00b1\u00c5\u0178d\u00c3\u00b6rt\", 64)\n , ( \"altm\u00c4\u00b1\u00c5\u0178d\u00c3\u00b6rt\", 64)\n , ( \"atm\u00c4\u00b1\u00c5\u0178be\u00c5\u0178\", 65)\n , ( \"altm\u00c4\u00b1\u00c5\u0178be\u00c5\u0178\", 65)\n , ( \"atm\u00c4\u00b1\u00c5\u0178alt\u00c4\u00b1\", 66)\n , ( \"altm\u00c4\u00b1\u00c5\u0178alt\u00c4\u00b1\", 66)\n , ( \"altm\u00c4\u00b1\u00c5\u0178yedi\", 67)\n , ( \"atm\u00c4\u00b1\u00c5\u0178yedi\", 67)\n , ( \"altm\u00c4\u00b1\u00c5\u0178sekiz\", 68)\n , ( \"atm\u00c4\u00b1\u00c5\u0178sekiz\", 68)\n , ( \"atm\u00c4\u00b1\u00c5\u0178dokuz\", 69)\n , ( \"altm\u00c4\u00b1\u00c5\u0178dokuz\", 69)\n , ( \"yetmi\u00c5\u0178bir\", 71)\n , ( \"yetmi\u00c5\u0178bi\", 71)\n , ( \"yetmi\u00c5\u0178iki\", 72)\n , ( \"yetmi\u00c5\u0178\u00c3\u00bc\u00c3\u00a7\", 73)\n , ( \"yetmi\u00c5\u0178d\u00c3\u00b6rt\", 74)\n , ( \"yetmi\u00c5\u0178be\u00c5\u0178\", 75)\n , ( \"yetmi\u00c5\u0178alt\u00c4\u00b1\", 76)\n , ( \"yetmi\u00c5\u0178yedi\", 77)\n , ( \"yetmi\u00c5\u0178sekiz\", 78)\n , ( \"yetmi\u00c5\u0178dokuz\", 79)\n , ( \"seksenbir\", 81)\n , ( \"seksenbi\", 81)\n , ( \"sekseniki\", 82)\n , ( \"seksen\u00c3\u00bc\u00c3\u00a7\", 83)\n , ( \"seksend\u00c3\u00b6rt\", 84)\n , ( \"seksenbe\u00c5\u0178\", 85)\n , ( \"seksenalt\u00c4\u00b1\", 86)\n , ( \"seksenyedi\", 87)\n , ( \"seksensekiz\", 88)\n , ( \"seksendokuz\", 89)\n , ( \"doksanbi\", 91)\n , ( \"doksanbir\", 91)\n , ( \"doksaniki\", 92)\n , ( \"doksan\u00c3\u00bc\u00c3\u00a7\", 93)\n , ( \"doksand\u00c3\u00b6rt\", 94)\n , ( \"doksanbe\u00c5\u0178\", 95)\n , ( \"doksanalt\u00c4\u00b1\", 96)\n , ( \"doksanyedi\", 97)\n , ( \"doksansekiz\", 98)\n , ( \"doksandokuz\", 99)\n ]\n\nruleInteger3 :: Rule\nruleInteger3 = Rule\n { name = \"integer 11..19 21..29 31..39 41..49 51..59 61..69 71..79 81..89 91..99\"\n , pattern =\n [ regex \"((on|yirmi|otuz|k\u00c4\u00b1rk|elli|atm\u00c4\u00b1\u00c5\u0178|altm\u00c4\u00b1\u00c5\u0178|yetmi\u00c5\u0178|seksen|doksan)(bir|bi|iki|\u00c3\u00bc\u00c3\u00a7|d\u00c3\u00b6rt|be\u00c5\u0178|alt\u00c4\u00b1|yedi|sekiz|dokuz))\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) tenToNintynineMap >>= integer\n _ -> Nothing\n }\n\n\nthousandsMap :: HashMap Text Integer\nthousandsMap = HashMap.fromList\n [ ( \"bin\", 1000)\n , ( \"ikibin\", 2000)\n , ( \"\u00c3\u00bc\u00c3\u00a7bin\", 3000)\n , ( \"d\u00c3\u00b6rtbin\", 4000)\n , ( \"be\u00c5\u0178bin\", 5000)\n , ( \"alt\u00c4\u00b1bin\", 6000)\n , ( \"yedibin\", 7000)\n , ( \"sekizbin\", 8000)\n , ( \"dokuzbin\", 9000)\n ]\n\nruleInteger6 :: Rule\nruleInteger6 = Rule\n { name = \"integer 1000..9000\"\n , pattern =\n [ regex \"(bin|ikibin|\u00c3\u00bc\u00c3\u00a7bin|d\u00c3\u00b6rtbin|be\u00c5\u0178bin|alt\u00c4\u00b1bin|yedibin|sekizbin|dokuzbin)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) thousandsMap >>= integer >>= withGrain 3\n _ -> Nothing\n }\n\nruleIntersect :: Rule\nruleIntersect = Rule\n { name = \"intersect\"\n , pattern =\n [ Predicate hasGrain\n , Predicate $ and . sequence [not . isMultipliable, isPositive]\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = val1, TNumeral.grain = Just g}:\n Token Numeral NumeralData{TNumeral.value = val2}:\n _) | (10 ** fromIntegral g) > val2 -> double $ val1 + val2\n _ -> Nothing\n }\n\nruleNumeralsSuffixesKMG :: Rule\nruleNumeralsSuffixesKMG = Rule\n { name = \"numbers suffixes (K, M, G)\"\n , pattern =\n [ dimension Numeral\n , regex \"([kmgb])(?=[\\\\W\\\\$\u00e2\u201a\u00ac]|$)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v}:\n Token RegexMatch (GroupMatch (match:_)):\n _) -> case Text.toLower match of\n \"k\" -> double $ v * 1e3\n \"b\" -> double $ v * 1e3\n \"m\" -> double $ v * 1e6\n \"g\" -> double $ v * 1e9\n _ -> Nothing\n _ -> Nothing\n }\n\nrulePowersOfTen :: Rule\nrulePowersOfTen = Rule\n { name = \"powers of tens\"\n , pattern =\n [ regex \"(y(\u00c3\u00bc)z|bin|milyon)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of\n \"y\u00c3\u00bcz\" -> double 1e2 >>= withGrain 2 >>= withMultipliable\n \"bin\" -> double 1e3 >>= withGrain 3 >>= withMultipliable\n \"milyon\" -> double 1e6 >>= withGrain 6 >>= withMultipliable\n _ -> Nothing\n _ -> Nothing\n }\n\ntenThousandsMap :: HashMap Text Integer\ntenThousandsMap = HashMap.fromList\n [ ( \"onbin\", 10000)\n , ( \"yirmibin\", 20000)\n , ( \"otuzbin\", 30000)\n , ( \"k\u00c4\u00b1rkbin\", 40000)\n , ( \"ellibin\", 50000)\n , ( \"altm\u00c4\u00b1\u00c5\u0178bin\", 60000)\n , ( \"atm\u00c4\u00b1\u00c5\u0178bin\", 60000)\n , ( \"yetmi\u00c5\u0178bin\", 70000)\n , ( \"seksenbin\", 80000)\n , ( \"doksanbin\", 90000)\n ]\n\nruleInteger7 :: Rule\nruleInteger7 = Rule\n { name = \"integer 10000..90000\"\n , pattern =\n [ regex \"(onbin|yirmibin|otuzbin|k\u00c4\u00b1rkbin|ellibin|atm\u00c4\u00b1\u00c5\u0178bin|altm\u00c4\u00b1\u00c5\u0178bin|yetmi\u00c5\u0178bin|seksenbin|doksanbin)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) tenThousandsMap >>= integer >>= withGrain 4\n _ -> Nothing\n }\n\nhundredThousandsMap :: HashMap Text Integer\nhundredThousandsMap = HashMap.fromList\n [ ( \"y\u00c3\u00bczbin\", 100000)\n , ( \"ikiy\u00c3\u00bczbin\", 200000)\n , ( \"\u00c3\u00bc\u00c3\u00a7y\u00c3\u00bczbin\", 300000)\n , ( \"d\u00c3\u00b6rty\u00c3\u00bczbin\", 400000)\n , ( \"be\u00c5\u0178y\u00c3\u00bczbin\", 500000)\n , ( \"alt\u00c4\u00b1y\u00c3\u00bczbin\", 600000)\n , ( \"yediy\u00c3\u00bczbin\", 700000)\n , ( \"sekizy\u00c3\u00bczbin\", 800000)\n , ( \"dokuzy\u00c3\u00bczbin\", 900000)\n ]\n\nruleInteger8 :: Rule\nruleInteger8 = Rule\n { name = \"integer 100000..900000\"\n , pattern =\n [ regex \"(y\u00c3\u00bczbin|ikiy\u00c3\u00bczbin|\u00c3\u00bc\u00c3\u00a7y\u00c3\u00bczbin|d\u00c3\u00b6rty\u00c3\u00bczbin|be\u00c5\u0178y\u00c3\u00bczbin|alt\u00c4\u00b1y\u00c3\u00bczbin|yediy\u00c3\u00bczbin|sekizy\u00c3\u00bczbin|dokuzy\u00c3\u00bczbin)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) hundredThousandsMap >>= integer >>= withGrain 5\n _ -> Nothing\n }\n\nruleHalf :: Rule\nruleHalf = Rule\n { name = \"half\"\n , pattern =\n [ regex \"(yar\u00c4\u00b1m)\"\n ]\n , prod = \\_ -> double 0.5\n }\n\ninteger9Map :: HashMap Text Double\ninteger9Map = HashMap.fromList\n [ ( \"onbirbu\u00c3\u00a7uk\", 11.5)\n , ( \"onbibu\u00c3\u00a7uk\", 11.5)\n , ( \"onikibu\u00c3\u00a7uk\", 12.5)\n , ( \"on\u00c3\u00bc\u00c3\u00a7bu\u00c3\u00a7uk\", 13.5)\n , ( \"ond\u00c3\u00b6rtbu\u00c3\u00a7uk\", 14.5)\n , ( \"onbe\u00c5\u0178bu\u00c3\u00a7uk\", 15.5)\n , ( \"onalt\u00c4\u00b1bu\u00c3\u00a7uk\", 16.5)\n , ( \"onyedibu\u00c3\u00a7uk\", 17.5)\n , ( \"onsekizbu\u00c3\u00a7uk\", 18.5)\n , ( \"ondokuzbu\u00c3\u00a7uk\", 19.5)\n , ( \"yirmibibu\u00c3\u00a7uk\", 21.5)\n , ( \"yirmibirbu\u00c3\u00a7uk\", 21.5)\n , ( \"yirmiikibu\u00c3\u00a7uk\", 22.5)\n , ( \"yirmi\u00c3\u00bc\u00c3\u00a7bu\u00c3\u00a7uk\", 23.5)\n , ( \"yirmid\u00c3\u00b6rtbu\u00c3\u00a7uk\", 24.5)\n , ( \"yirmibe\u00c5\u0178bu\u00c3\u00a7uk\", 25.5)\n , ( \"yirmialt\u00c4\u00b1bu\u00c3\u00a7uk\", 26.5)\n , ( \"yirmiyedibu\u00c3\u00a7uk\", 27.5)\n , ( \"yirmisekizbu\u00c3\u00a7uk\", 28.5)\n , ( \"yirmidokuzbu\u00c3\u00a7uk\", 29.5)\n , ( \"otuzbibu\u00c3\u00a7uk\", 31.5)\n , ( \"otuzbirbu\u00c3\u00a7uk\", 31.5)\n , ( \"otuzikibu\u00c3\u00a7uk\", 32.5)\n , ( \"otuz\u00c3\u00bc\u00c3\u00a7bu\u00c3\u00a7uk\", 33.5)\n , ( \"otuzd\u00c3\u00b6rtbu\u00c3\u00a7uk\", 34.5)\n , ( \"otuzbe\u00c5\u0178bu\u00c3\u00a7uk\", 35.5)\n , ( \"otuzalt\u00c4\u00b1bu\u00c3\u00a7uk\", 36.5)\n , ( \"otuzyedibu\u00c3\u00a7uk\", 37.5)\n , ( \"otuzsekizbu\u00c3\u00a7uk\", 38.5)\n , ( \"otuzdokuzbu\u00c3\u00a7uk\", 39.5)\n , ( \"k\u00c4\u00b1rkbirbu\u00c3\u00a7uk\", 41.5)\n , ( \"k\u00c4\u00b1rkbibu\u00c3\u00a7uk\", 41.5)\n , ( \"k\u00c4\u00b1rkikibu\u00c3\u00a7uk\", 42.5)\n , ( \"k\u00c4\u00b1rk\u00c3\u00bc\u00c3\u00a7bu\u00c3\u00a7uk\", 43.5)\n , ( \"k\u00c4\u00b1rkd\u00c3\u00b6rtbu\u00c3\u00a7uk\", 44.5)\n , ( \"k\u00c4\u00b1rkbe\u00c5\u0178bu\u00c3\u00a7uk\", 45.5)\n , ( \"k\u00c4\u00b1rkalt\u00c4\u00b1bu\u00c3\u00a7uk\", 46.5)\n , ( \"k\u00c4\u00b1rkyedibu\u00c3\u00a7uk\", 47.5)\n , ( \"k\u00c4\u00b1rksekizbu\u00c3\u00a7uk\", 48.5)\n , ( \"k\u00c4\u00b1rkdokuzbu\u00c3\u00a7uk\", 49.5)\n , ( \"ellibibu\u00c3\u00a7uk\", 51.5)\n , ( \"ellibirbu\u00c3\u00a7uk\", 51.5)\n , ( \"elliikibu\u00c3\u00a7uk\", 52.5)\n , ( \"elli\u00c3\u00bc\u00c3\u00a7bu\u00c3\u00a7uk\", 53.5)\n , ( \"ellid\u00c3\u00b6rtbu\u00c3\u00a7uk\", 54.5)\n , ( \"ellibe\u00c5\u0178bu\u00c3\u00a7uk\", 55.5)\n , ( \"ellialt\u00c4\u00b1bu\u00c3\u00a7uk\", 56.5)\n , ( \"elliyedibu\u00c3\u00a7uk\", 57.5)\n , ( \"ellisekizbu\u00c3\u00a7uk\", 58.5)\n , ( \"ellidokuzbu\u00c3\u00a7uk\", 59.5)\n , ( \"altm\u00c4\u00b1\u00c5\u0178birbu\u00c3\u00a7uk\", 61.5)\n , ( \"atm\u00c4\u00b1\u00c5\u0178birbu\u00c3\u00a7uk\", 61.5)\n , ( \"altm\u00c4\u00b1\u00c5\u0178ikibu\u00c3\u00a7uk\", 62.5)\n , ( \"atm\u00c4\u00b1\u00c5\u0178ikibu\u00c3\u00a7uk\", 62.5)\n , ( \"atm\u00c4\u00b1\u00c5\u0178\u00c3\u00bc\u00c3\u00a7bu\u00c3\u00a7uk\", 63.5)\n , ( \"altm\u00c4\u00b1\u00c5\u0178\u00c3\u00bc\u00c3\u00a7bu\u00c3\u00a7uk\", 63.5)\n , ( \"altm\u00c4\u00b1\u00c5\u0178d\u00c3\u00b6rtbu\u00c3\u00a7uk\", 64.5)\n , ( \"atm\u00c4\u00b1\u00c5\u0178d\u00c3\u00b6rtbu\u00c3\u00a7uk\", 64.5)\n , ( \"altm\u00c4\u00b1\u00c5\u0178be\u00c5\u0178bu\u00c3\u00a7uk\", 65.5)\n , ( \"atm\u00c4\u00b1\u00c5\u0178be\u00c5\u0178bu\u00c3\u00a7uk\", 65.5)\n , ( \"altm\u00c4\u00b1\u00c5\u0178alt\u00c4\u00b1bu\u00c3\u00a7uk\", 66.5)\n , ( \"atm\u00c4\u00b1\u00c5\u0178alt\u00c4\u00b1bu\u00c3\u00a7uk\", 66.5)\n , ( \"atm\u00c4\u00b1\u00c5\u0178yedibu\u00c3\u00a7uk\", 67.5)\n , ( \"altm\u00c4\u00b1\u00c5\u0178yedibu\u00c3\u00a7uk\", 67.5)\n , ( \"altm\u00c4\u00b1\u00c5\u0178sekizbu\u00c3\u00a7uk\", 68.5)\n , ( \"atm\u00c4\u00b1\u00c5\u0178sekizbu\u00c3\u00a7uk\", 68.5)\n , ( \"altm\u00c4\u00b1\u00c5\u0178dokuzbu\u00c3\u00a7uk\", 69.5)\n , ( \"atm\u00c4\u00b1\u00c5\u0178dokuzbu\u00c3\u00a7uk\", 69.5)\n , ( \"yetmi\u00c5\u0178bibu\u00c3\u00a7uk\", 71.5)\n , ( \"yetmi\u00c5\u0178birbu\u00c3\u00a7uk\", 71.5)\n , ( \"yetmi\u00c5\u0178ikibu\u00c3\u00a7uk\", 72.5)\n , ( \"yetmi\u00c5\u0178\u00c3\u00bc\u00c3\u00a7bu\u00c3\u00a7uk\", 73.5)\n , ( \"yetmi\u00c5\u0178d\u00c3\u00b6rtbu\u00c3\u00a7uk\", 74.5)\n , ( \"yetmi\u00c5\u0178be\u00c5\u0178bu\u00c3\u00a7uk\", 75.5)\n , ( \"yetmi\u00c5\u0178alt\u00c4\u00b1bu\u00c3\u00a7uk\", 76.5)\n , ( \"yetmi\u00c5\u0178yedibu\u00c3\u00a7uk\", 77.5)\n , ( \"yetmi\u00c5\u0178sekizbu\u00c3\u00a7uk\", 78.5)\n , ( \"yetmi\u00c5\u0178dokuzbu\u00c3\u00a7uk\", 79.5)\n , ( \"seksenbibu\u00c3\u00a7uk\", 81.5)\n , ( \"seksenbirbu\u00c3\u00a7uk\", 81.5)\n , ( \"seksenikibu\u00c3\u00a7uk\", 82.5)\n , ( \"seksen\u00c3\u00bc\u00c3\u00a7bu\u00c3\u00a7uk\", 83.5)\n , ( \"seksend\u00c3\u00b6rtbu\u00c3\u00a7uk\", 84.5)\n , ( \"seksenbe\u00c5\u0178bu\u00c3\u00a7uk\", 85.5)\n , ( \"seksenalt\u00c4\u00b1bu\u00c3\u00a7uk\", 86.5)\n , ( \"seksenyedibu\u00c3\u00a7uk\", 87.5)\n , ( \"seksensekizbu\u00c3\u00a7uk\", 88.5)\n , ( \"seksendokuzbu\u00c3\u00a7uk\", 89.5)\n , ( \"doksanbirbu\u00c3\u00a7uk\", 91.5)\n , ( \"doksanbibu\u00c3\u00a7uk\", 91.5)\n , ( \"doksanikibu\u00c3\u00a7uk\", 92.5)\n , ( \"doksan\u00c3\u00bc\u00c3\u00a7bu\u00c3\u00a7uk\", 93.5)\n , ( \"doksand\u00c3\u00b6rtbu\u00c3\u00a7uk\", 94.5)\n , ( \"doksanbe\u00c5\u0178bu\u00c3\u00a7uk\", 95.5)\n , ( \"doksanalt\u00c4\u00b1bu\u00c3\u00a7uk\", 96.5)\n , ( \"doksanyedibu\u00c3\u00a7uk\", 97.5)\n , ( \"doksansekizbu\u00c3\u00a7uk\", 98.5)\n , ( \"doksandokuzbu\u00c3\u00a7uk\", 99.5)\n ]\n\nruleInteger9 :: Rule\nruleInteger9 = Rule\n { name = \"integer 11..19 21..29 31..39 41..49 51..59 61..69 71..79 81..89 91..99\"\n , pattern =\n [ regex \"((on|yirmi|otuz|k\u00c4\u00b1rk|elli|atm\u00c4\u00b1\u00c5\u0178|altm\u00c4\u00b1\u00c5\u0178|yetmi\u00c5\u0178|seksen|doksan)(bir|bi|iki|\u00c3\u00bc\u00c3\u00a7\u00c3\u00bc?|d\u00c3\u00b6rt|be\u00c5\u0178|alt\u00c4\u00b1|yedi|sekiz|dokuz)(bu\u00c3\u00a7uk))\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) integer9Map >>= double\n _ -> Nothing\n }\n\nruleDozen :: Rule\nruleDozen = Rule\n { name = \"dozen\"\n , pattern =\n [ regex \"d\u00c3\u00bczine\"\n ]\n , prod = \\_ -> integer 12 >>= withGrain 1 >>= withMultipliable\n }\n\noneToNineMap :: HashMap Text Integer\noneToNineMap = HashMap.fromList\n [ ( \"s\\305f\\305r\", 0)\n , ( \"yok\", 0)\n , ( \"hi\u00c3\u00a7\", 0)\n , ( \"bir\", 1)\n , ( \"bi\", 1)\n , ( \"yek\", 1)\n , ( \"tek\", 1)\n , ( \"iki\", 2)\n , ( \"\u00c3\u00bc\u00c3\u00a7\", 3)\n , ( \"\u00c3\u00bc\u00c3\u00a7\u00c3\u00bc\", 3)\n , ( \"d\u00c3\u00b6rt\", 4)\n , ( \"be\u00c5\u0178\", 5)\n , ( \"alt\u00c4\u00b1\", 6)\n , ( \"yedi\", 7)\n , ( \"sekiz\", 8)\n , ( \"dokuz\", 9)\n ]\n\nruleInteger :: Rule\nruleInteger = Rule\n { name = \"integer (0..9)\"\n , pattern =\n [ regex \"(yok|hi(\u00c3\u00a7)|s(\u00c4\u00b1)f(\u00c4\u00b1)r|bir?|[ty]ek|iki|(\u00c3\u00bc)(\u00c3\u00a7)(\u00c3\u00bc)?|d(\u00c3\u00b6)rt|be(\u00c5\u0178)|alt(\u00c4\u00b1)|yedi|sekiz|dokuz)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) oneToNineMap >>= integer\n _ -> Nothing\n }\n\nnumeralSuffixesHalfsuffixText2Map :: HashMap Text Double\nnumeralSuffixesHalfsuffixText2Map = HashMap.fromList\n [ ( \"onbu\u00c3\u00a7uk\", 10.5)\n , ( \"yirmibu\u00c3\u00a7uk\", 20.5)\n , ( \"otuzbu\u00c3\u00a7uk\", 30.5)\n , ( \"k\u00c4\u00b1rkbu\u00c3\u00a7uk\", 40.5)\n , ( \"ellibu\u00c3\u00a7uk\", 50.5)\n , ( \"atm\u00c4\u00b1\u00c5\u0178bu\u00c3\u00a7uk\", 60.5)\n , ( \"altm\u00c4\u00b1\u00c5\u0178bu\u00c3\u00a7uk\", 60.5)\n , ( \"yetmi\u00c5\u0178bu\u00c3\u00a7uk\", 70.5)\n , ( \"seksenbu\u00c3\u00a7uk\", 80.5)\n , ( \"doksanbu\u00c3\u00a7uk\", 90.5)\n ]\n\nruleNumeralSuffixesHalfsuffixText2 :: Rule\nruleNumeralSuffixesHalfsuffixText2 = Rule\n { name = \"number suffixes (half-suffix text) (10..90)\"\n , pattern =\n [ regex \"((on|yirmi|otuz|k\u00c4\u00b1rk|elli|atm\u00c4\u00b1\u00c5\u0178|altm\u00c4\u00b1\u00c5\u0178|yetmi\u00c5\u0178|seksen|doksan)(bu\u00c3\u00a7uk))\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) numeralSuffixesHalfsuffixText2Map\n >>= double\n _ -> Nothing\n }\n\nruleNumeralSuffixesHalfSuffix :: Rule\nruleNumeralSuffixesHalfSuffix = Rule\n { name = \"number suffixes (half-suffix)\"\n , pattern =\n [ dimension Numeral\n , regex \"(bu\u00c3\u00a7uk)(?=[\\\\W\\\\$\u00e2\u201a\u00ac]|$)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v}:_) -> double $ v + 0.5\n _ -> Nothing\n }\n\nruleInteger4 :: Rule\nruleInteger4 = Rule\n { name = \"integer 11..99\"\n , pattern =\n [ oneOf [70, 20, 60, 50, 40, 90, 30, 10, 80]\n , Predicate $ numberBetween 1 10\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v1}:\n Token Numeral NumeralData{TNumeral.value = v2}:\n _) -> double $ v1 + v2\n _ -> Nothing\n }\n\nruleGroupOfTens :: Rule\nruleGroupOfTens = Rule\n { name = \"group of ten(s)\"\n , pattern =\n [ regex \"deste\"\n ]\n , prod = \\_ -> integer 10 >>= withGrain 1 >>= withMultipliable\n }\n\ntensMap :: HashMap Text Integer\ntensMap = HashMap.fromList\n [ ( \"on\", 10)\n , ( \"yirmi\", 20)\n , ( \"otuz\", 30)\n , ( \"k\u00c4\u00b1rk\", 40)\n , ( \"elli\", 50)\n , ( \"altm\u00c4\u00b1\u00c5\u0178\", 60)\n , ( \"atm\u00c4\u00b1\u00c5\u0178\", 60)\n , ( \"yetmi\u00c5\u0178\", 70)\n , ( \"seksen\", 80)\n , ( \"doksan\", 90)\n ]\n\nruleInteger2 :: Rule\nruleInteger2 = Rule\n { name = \"integer (10..90)\"\n , pattern =\n [ regex \"(on|yirmi|otuz|k\u00c4\u00b1rk|elli|atm\u00c4\u00b1\u00c5\u0178|altm\u00c4\u00b1\u00c5\u0178|yetmi\u00c5\u0178|seksen|doksan)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n HashMap.lookup (Text.toLower match) tensMap >>= integer\n _ -> Nothing\n }\n\nruleQuarter :: Rule\nruleQuarter = Rule\n { name = \"quarter\"\n , pattern =\n [ regex \"(\u00c3\u00a7eyrek)\"\n ]\n , prod = \\_ -> double 0.25\n }\n\nruleNumeralDotNumeral :: Rule\nruleNumeralDotNumeral = Rule\n { name = \"number dot number\"\n , pattern =\n [ dimension Numeral\n , regex \"nokta|virg\u00c3\u00bcl\"\n , Predicate $ not . hasGrain\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v1}:\n _:\n Token Numeral NumeralData{TNumeral.value = v2}:\n _) -> double $ v1 + decimalsToDouble v2\n _ -> Nothing\n }\n\nruleIntegerWithThousandsSeparator :: Rule\nruleIntegerWithThousandsSeparator = Rule\n { name = \"integer with thousands separator .\"\n , pattern =\n [ regex \"(\\\\d{1,3}(\\\\.\\\\d\\\\d\\\\d){1,5})\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n parseDouble (Text.replace \".\" Text.empty match) >>= double\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleACoupleOf\n , ruleDecimalNumeral\n , ruleDecimalWithThousandsSeparator\n , ruleDozen\n , ruleFew\n , ruleGroupOfTens\n , ruleHalf\n , ruleInteger\n , ruleInteger2\n , ruleInteger3\n , ruleInteger4\n , ruleInteger5\n , ruleInteger6\n , ruleInteger7\n , ruleInteger8\n , ruleInteger9\n , ruleIntegerWithThousandsSeparator\n , ruleIntersect\n , ruleNumeralDotNumeral\n , ruleNumeralSuffixesHalfSuffix\n , ruleNumeralSuffixesHalfsuffixText\n , ruleNumeralSuffixesHalfsuffixText2\n , ruleNumeralsPrefixWithNegativeOrMinus\n , ruleNumeralsSuffixesKMG\n , rulePowersOfTen\n , ruleQuarter\n , ruleTen\n , ruleMultiply\n ]\n", "num_lines": 722} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n\nmodule Duckling.Ordinal.Helpers\n ( ordinal\n , oneOf\n ) where\n\nimport Prelude\n\nimport Duckling.Dimensions.Types\nimport Duckling.Ordinal.Types (OrdinalData (..))\nimport Duckling.Types\nimport qualified Duckling.Ordinal.Types as TOrdinal\n\n-- -----------------------------------------------------------------\n-- Patterns\n\noneOf :: [Int] -> PatternItem\noneOf vs = Predicate $ \\x ->\n case x of\n (Token Ordinal OrdinalData {TOrdinal.value = v}) -> elem v vs\n _ -> False\n\n-- -----------------------------------------------------------------\n-- Production\n\nordinal :: Int -> Token\nordinal x = Token Ordinal OrdinalData {TOrdinal.value = x}\n", "num_lines": 36} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE DeriveAnyClass #-}\n{-# LANGUAGE DeriveGeneric #-}\n{-# LANGUAGE NoRebindableSyntax #-}\n{-# LANGUAGE OverloadedStrings #-}\n{-# LANGUAGE TypeFamilies #-}\n\nmodule Duckling.Ordinal.Types where\n\nimport Control.DeepSeq\nimport Data.Aeson\nimport Data.Hashable\nimport Data.Text (Text)\nimport GHC.Generics\nimport Prelude\n\nimport Duckling.Resolve (Resolve(..))\n\nnewtype OrdinalData = OrdinalData { value :: Int }\n deriving (Eq, Generic, Hashable, Show, Ord, NFData)\n\ninstance Resolve OrdinalData where\n type ResolvedValue OrdinalData = OrdinalData\n resolve _ _ x = Just (x, False)\n\ninstance ToJSON OrdinalData where\n toJSON (OrdinalData value) = object\n [ \"type\" .= (\"value\" :: Text)\n , \"value\" .= value\n ]\n\nisBetween :: Ord a => a -> a -> a -> Bool\nisBetween x low high = low <= x && x <= high\n", "num_lines": 40} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Ordinal.AR.Corpus\n ( corpus\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Locale\nimport Duckling.Ordinal.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale AR Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (OrdinalData 1)\n [ \"\u00d8\u00a7\u00d9\u201e\u00d8\u00a7\u00d9\u02c6\u00d9\u201e\"\n , \"\u00d8\u00a7\u00d9\u201e\u00d8\u00a3\u00d9\u02c6\u00d9\u201e\"\n , \"\u00d8\u00a7\u00d9\u02c6\u00d9\u201e\"\n ]\n , examples (OrdinalData 2)\n [ \"\u00d8\u00a7\u00d9\u201e\u00d8\u00ab\u00d8\u00a7\u00d9\u2020\u00d9\u0160\"\n , \"\u00d8\u00a7\u00d9\u201e\u00d8\u00ab\u00d8\u00a7\u00d9\u2020\"\n , \"\u00d8\u00ab\u00d8\u00a7\u00d9\u2020\u00d9\u0160\"\n ]\n , examples (OrdinalData 3)\n [ \"\u00d8\u00a7\u00d9\u201e\u00d8\u00ab\u00d8\u00a7\u00d9\u201e\u00d8\u00ab\"\n , \"\u00d8\u00ab\u00d8\u00a7\u00d9\u201e\u00d8\u00ab\"\n ]\n , examples (OrdinalData 4)\n [ \"\u00d8\u00a7\u00d9\u201e\u00d8\u00b1\u00d8\u00a7\u00d8\u00a8\u00d8\u00b9\"\n , \"\u00d8\u00b1\u00d8\u00a7\u00d8\u00a8\u00d8\u00b9\"\n ]\n , examples (OrdinalData 8)\n [ \"\u00d8\u00a7\u00d9\u201e\u00d8\u00ab\u00d8\u00a7\u00d9\u2026\u00d9\u2020\"\n , \"\u00d8\u00ab\u00d8\u00a7\u00d9\u2026\u00d9\u2020\"\n ]\n , examples (OrdinalData 11)\n [ \"\u00d8\u00a7\u00d9\u201e\u00d8\u00a3\u00d8\u00ad\u00d8\u00af \u00d8\u00b9\u00d8\u00b4\u00d8\u00b1\"\n , \"\u00d8\u00a7\u00d9\u201e\u00d8\u00a5\u00d8\u00ad\u00d8\u00af\u00d9\u2030 \u00d8\u00b9\u00d8\u00b4\u00d8\u00b1\u00d8\u00a9\"\n , \"\u00d8\u00a7\u00d9\u201e\u00d8\u00ad\u00d8\u00a7\u00d8\u00af\u00d9\u0160 \u00d8\u00b9\u00d8\u00b4\u00d8\u00b1\u00d8\u00a9\"\n ]\n , examples (OrdinalData 12)\n [ \"\u00d8\u00a7\u00d9\u201e\u00d8\u00ab\u00d8\u00a7\u00d9\u2020\u00d9\u0160 \u00d8\u00b9\u00d8\u00b4\u00d8\u00b1\u00d8\u00a9\"\n , \"\u00d8\u00a7\u00d9\u201e\u00d8\u00ab\u00d8\u00a7\u00d9\u2020 \u00d8\u00b9\u00d8\u00b4\u00d8\u00b1\"\n , \"\u00d8\u00a7\u00d9\u201e\u00d8\u00a7\u00d8\u00ab\u00d9\u2020\u00d9\u2030 \u00d8\u00b9\u00d8\u00b4\u00d8\u00b1\"\n ]\n , examples (OrdinalData 13)\n [ \"\u00d8\u00a7\u00d9\u201e\u00d8\u00ab\u00d8\u00a7\u00d9\u201e\u00d8\u00ab \u00d8\u00b9\u00d8\u00b4\u00d8\u00b1\"\n , \"\u00d8\u00a7\u00d9\u201e\u00d8\u00ab\u00d8\u00a7\u00d9\u201e\u00d8\u00ab\u00d8\u00a9 \u00d8\u00b9\u00d8\u00b4\u00d8\u00b1\u00d8\u00a9\"\n ]\n , examples (OrdinalData 21)\n [ \"\u00d8\u00a7\u00d9\u201e\u00d8\u00ad\u00d8\u00a7\u00d8\u00af\u00d9\u0160 \u00d9\u02c6\u00d8\u00a7\u00d9\u201e\u00d8\u00b9\u00d8\u00b4\u00d8\u00b1\u00d9\u0160\u00d9\u2020\"\n , \"\u00d8\u00a7\u00d9\u201e\u00d9\u02c6\u00d8\u00a7\u00d8\u00ad\u00d8\u00af \u00d9\u02c6 \u00d8\u00a7\u00d9\u201e\u00d8\u00b9\u00d8\u00b4\u00d8\u00b1\u00d9\u02c6\u00d9\u2020\"\n ]\n , examples (OrdinalData 25)\n [ \"\u00d8\u00a7\u00d9\u201e\u00d8\u00ae\u00d8\u00a7\u00d9\u2026\u00d8\u00b3 \u00d9\u02c6\u00d8\u00a7\u00d9\u201e\u00d8\u00b9\u00d8\u00b4\u00d8\u00b1\u00d9\u0160\u00d9\u2020\"\n , \"\u00d8\u00a7\u00d9\u201e\u00d8\u00ae\u00d8\u00a7\u00d9\u2026\u00d8\u00b3 \u00d9\u02c6 \u00d8\u00a7\u00d9\u201e\u00d8\u00b9\u00d8\u00b4\u00d8\u00b1\u00d9\u02c6\u00d9\u2020\"\n ]\n , examples (OrdinalData 31)\n [ \"\u00d8\u00a7\u00d9\u201e\u00d9\u02c6\u00d8\u00a7\u00d8\u00ad\u00d8\u00af \u00d9\u02c6\u00d8\u00a7\u00d9\u201e\u00d8\u00ab\u00d9\u201e\u00d8\u00a7\u00d8\u00ab\u00d9\u02c6\u00d9\u2020\"\n , \"\u00d8\u00a7\u00d9\u201e\u00d9\u02c6\u00d8\u00a7\u00d8\u00ad\u00d8\u00af \u00d9\u02c6\u00d8\u00a7\u00d9\u201e\u00d8\u00ab\u00d9\u201e\u00d8\u00a7\u00d8\u00ab\u00d9\u0160\u00d9\u2020\"\n ]\n , examples (OrdinalData 72)\n [ \"\u00d8\u00a7\u00d9\u201e\u00d8\u00ab\u00d8\u00a7\u00d9\u2020 \u00d9\u02c6\u00d8\u00a7\u00d9\u201e\u00d8\u00b3\u00d8\u00a8\u00d8\u00b9\u00d9\u02c6\u00d9\u2020\"\n , \"\u00d8\u00a7\u00d9\u201e\u00d8\u00ab\u00d8\u00a7\u00d9\u2020\u00d9\u0160 \u00d9\u02c6\u00d8\u00a7\u00d9\u201e\u00d8\u00b3\u00d8\u00a8\u00d8\u00b9\u00d9\u0160\u00d9\u2020\"\n ]\n , examples (OrdinalData 90)\n [ \"\u00d8\u00a7\u00d9\u201e\u00d8\u00aa\u00d8\u00b3\u00d8\u00b9\u00d9\u02c6\u00d9\u2020\"\n , \"\u00d8\u00a7\u00d9\u201e\u00d8\u00aa\u00d8\u00b3\u00d8\u00b9\u00d9\u0160\u00d9\u2020\"\n ]\n ]\n", "num_lines": 84} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Ordinal.CA.Corpus\n ( corpus ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Locale\nimport Duckling.Ordinal.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale CA Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (OrdinalData 1)\n [ \"primer\"\n , \"primera\"\n , \"primers\"\n , \"primeres\"\n ]\n , examples (OrdinalData 2)\n [ \"segon\"\n , \"segona\"\n , \"segons\"\n , \"segones\"\n ]\n , examples (OrdinalData 3)\n [ \"tercer\"\n , \"tercera\"\n , \"tercers\"\n , \"terceres\"\n ]\n , examples (OrdinalData 4)\n [ \"quart\"\n , \"quarta\"\n , \"quarts\"\n , \"quartes\"\n ]\n , examples (OrdinalData 5)\n [ \"cinqu\u00c3\u00a8\"\n , \"cinquena\"\n , \"cinquens\"\n , \"cinquenes\"\n ]\n , examples (OrdinalData 6)\n [ \"sis\u00c3\u00a8\"\n , \"sisena\"\n , \"sisens\"\n , \"sisenes\"\n ]\n , examples (OrdinalData 7)\n [ \"set\u00c3\u00a8\"\n , \"setena\"\n , \"setens\"\n , \"setenes\"\n ]\n , examples (OrdinalData 8)\n [ \"vuit\u00c3\u00a8\"\n , \"vuitena\"\n , \"vuitens\"\n , \"vuitenes\"\n ]\n , examples (OrdinalData 9)\n [ \"nov\u00c3\u00a8\"\n , \"novena\"\n , \"novens\"\n , \"novenes\"\n ]\n , examples (OrdinalData 10)\n [ \"des\u00c3\u00a8\"\n , \"desena\"\n , \"desens\"\n , \"desenes\"\n ]\n , examples (OrdinalData 11)\n [ \"onz\u00c3\u00a8\"\n , \"onzena\"\n ]\n , examples (OrdinalData 12)\n [ \"dotz\u00c3\u00a8\"\n , \"dotzena\"\n ]\n , examples (OrdinalData 13)\n [ \"tretz\u00c3\u00a8\"\n , \"tretzena\"\n ]\n , examples (OrdinalData 14)\n [ \"catorz\u00c3\u00a8\"\n , \"catorzena\"\n ]\n , examples (OrdinalData 15)\n [ \"quinz\u00c3\u00a8\"\n , \"quinzena\"\n ]\n , examples (OrdinalData 16)\n [ \"setz\u00c3\u00a8\"\n , \"setzena\"\n ]\n , examples (OrdinalData 17)\n [ \"disset\u00c3\u00a8\"\n , \"dissetena\"\n ]\n , examples (OrdinalData 18)\n [ \"divuit\u00c3\u00a8\"\n , \"divuitena\"\n ]\n , examples (OrdinalData 19)\n [ \"dinov\u00c3\u00a8\"\n , \"dinovena\"\n ]\n , examples (OrdinalData 20)\n [ \"vint\u00c3\u00a8\"\n , \"vintena\"\n ]\n ]\n", "num_lines": 127} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n{-# LANGUAGE LambdaCase #-}\n\nmodule Duckling.Ordinal.CA.Rules\n ( rules ) where\n\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\nimport Prelude\nimport Data.String\n\nimport Duckling.Dimensions.Types\nimport Duckling.Ordinal.Helpers\nimport Duckling.Regex.Types\nimport Duckling.Types\n\nordinalsMap :: HashMap.HashMap Text.Text Int\nordinalsMap = HashMap.fromList\n [ ( \"primer\" , 1 )\n , ( \"primers\" , 1 )\n , ( \"primera\" , 1 )\n , ( \"primeres\" , 1 )\n , ( \"segon\" , 2 )\n , ( \"segona\" , 2 )\n , ( \"segones\" , 2 )\n , ( \"segons\" , 2 )\n , ( \"tercer\" , 3 )\n , ( \"tercera\" , 3 )\n , ( \"tercers\" , 3 )\n , ( \"terceres\" , 3 )\n , ( \"quart\" , 4 )\n , ( \"quarta\" , 4 )\n , ( \"quarts\" , 4 )\n , ( \"quartes\" , 4 )\n , ( \"cinqu\u00c3\u00a8\" , 5 )\n , ( \"cinquena\" , 5 )\n , ( \"cinquens\" , 5 )\n , ( \"cinquenes\" , 5 )\n , ( \"sis\u00c3\u00a8\" , 6 )\n , ( \"sisena\" , 6 )\n , ( \"sisens\" , 6 )\n , ( \"sisenes\" , 6 )\n , ( \"set\u00c3\u00a8\" , 7 )\n , ( \"setena\" , 7 )\n , ( \"setens\" , 7 )\n , ( \"setenes\" , 7 )\n , ( \"vuit\u00c3\u00a8\" , 8 )\n , ( \"vuitena\" , 8 )\n , ( \"vuitens\" , 8 )\n , ( \"vuitenes\" , 8 )\n , ( \"nov\u00c3\u00a8\" , 9 )\n , ( \"novena\" , 9 )\n , ( \"novens\" , 9 )\n , ( \"novenes\" , 9 )\n , ( \"des\u00c3\u00a8\" , 10 )\n , ( \"desena\" , 10 )\n , ( \"desens\" , 10 )\n , ( \"desenes\" , 10 )\n , ( \"onz\u00c3\u00a8\" , 11 )\n , ( \"onzena\" , 11 )\n , ( \"dotz\u00c3\u00a8\" , 12 )\n , ( \"dotzena\" , 12 )\n , ( \"tretz\u00c3\u00a8\" , 13 )\n , ( \"tretzena\" , 13 )\n , ( \"catorz\u00c3\u00a8\" , 14 )\n , ( \"catorzena\" , 14 )\n , ( \"quinz\u00c3\u00a8\" , 15 )\n , ( \"quinzena\" , 15 )\n , ( \"setz\u00c3\u00a8\" , 16 )\n , ( \"setzena\" , 16 )\n , ( \"disset\u00c3\u00a8\" , 17 )\n , ( \"dissetena\" , 17 )\n , ( \"divuit\u00c3\u00a8\" , 18 )\n , ( \"divuitena\" , 18 )\n , ( \"dinov\u00c3\u00a8\" , 19 )\n , ( \"dinovena\" , 19 )\n , ( \"vint\u00c3\u00a8\" , 20 )\n , ( \"vintena\" , 20 )\n ]\n\nruleOrdinalsPrimero :: Rule\nruleOrdinalsPrimero = Rule\n { name = \"ordinals (primero..10)\"\n , pattern =\n [ regex \"(primer(a|s|es)?|segon(a|s|es)?|tercer(a|s|es)?|quart(a|s|es)?|cinqu(\u00c3\u00a8|(en(a|s|es)))|sis(\u00c3\u00a8|en(a|s|es))|set(\u00c3\u00a8|en(a|s|es))|vuit(\u00c3\u00a8|en(a|s|es))|nov(\u00c3\u00a8|en(a|s|es))|des(\u00c3\u00a8|en(a|s|es))|onz(\u00c3\u00a8|ena)|dotz(\u00c3\u00a8|ena)|tretz(\u00c3\u00a8|ena)|catorz(\u00c3\u00a8|ena)|quinz(\u00c3\u00a8|ena)|setz(\u00c3\u00a8|ena)|disset(\u00c3\u00a8|ena)|divuit(\u00c3\u00a8|ena)|dinov(\u00c3\u00a8|ena)|vint(\u00c3\u00a8|ena))\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n ordinal <$> HashMap.lookup (Text.toLower match) ordinalsMap\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleOrdinalsPrimero\n ]\n", "num_lines": 105} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Ordinal.DA.Corpus\n ( corpus ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Locale\nimport Duckling.Ordinal.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale DA Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (OrdinalData 4)\n [ \"4.\"\n , \"fjerde\"\n , \"Fjerde\"\n ]\n , examples (OrdinalData 41)\n [ \"enogfyrrende\"\n ]\n , examples (OrdinalData 78)\n [ \"otteoghalvfjerdsindstyvende\"\n ]\n , examples (OrdinalData 263)\n [ \"to hundrede og treogtresindstyvende\"\n , \"tohundrede og treogtresindstyvende\"\n ]\n , examples (OrdinalData 70)\n [ \"halvfjerdsende\"\n , \"halvfjerdsindstyvende\"\n ]\n ]\n", "num_lines": 46} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE NoRebindableSyntax #-}\n\nmodule Duckling.Ordinal.DA.Rules\n ( rules ) where\n\n\nimport Data.HashMap.Strict (HashMap)\nimport Data.Text (Text)\nimport Prelude\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers (parseInt, numberWith)\nimport Duckling.Numeral.Types (NumeralData (..), getIntValue)\nimport Duckling.Ordinal.Helpers\nimport Duckling.Ordinal.Types (OrdinalData (..))\nimport Duckling.Regex.Types\nimport Duckling.Types\nimport qualified Duckling.Numeral.Types as TNumeral\n\nordinalsMap :: HashMap Text Int\nordinalsMap = HashMap.fromList\n [ ( \"f\u00c3\u00b8rste\", 1 )\n , ( \"anden\", 2 )\n , ( \"tredje\", 3 )\n , ( \"fjerde\", 4 )\n , ( \"femte\", 5 )\n , ( \"sjette\", 6 )\n , ( \"syvende\", 7 )\n , ( \"ottende\", 8 )\n , ( \"niende\", 9 )\n , ( \"tiende\", 10 )\n , ( \"elfte\", 11 )\n , ( \"tolvte\", 12 )\n , ( \"trettende\", 13 )\n , ( \"fjortende\", 14 )\n , ( \"femtende\", 15 )\n , ( \"sekstende\", 16 )\n , ( \"syttende\", 17 )\n , ( \"attende\", 18 )\n , ( \"nittende\", 19 )\n , ( \"tyvende\", 20 )\n , ( \"tenogtyvende\", 21 )\n , ( \"toogtyvende\", 22 )\n , ( \"treogtyvende\", 23 )\n , ( \"fireogtyvende\", 24 )\n , ( \"femogtyvende\", 25 )\n , ( \"seksogtyvende\", 26 )\n , ( \"syvogtyvende\", 27 )\n , ( \"otteogtyvende\", 28 )\n , ( \"niogtyvende\", 29 )\n , ( \"tredivte\", 30 )\n , ( \"enogtredivte\", 31 )\n ]\n\ncardinalsMap :: HashMap Text Int\ncardinalsMap = HashMap.fromList\n [ ( \"tyvende\", 20 )\n , ( \"tredivte\", 30 )\n , ( \"fyrrende\", 40 )\n , ( \"fyrretyvende\", 40 )\n , ( \"halvtredsende\", 50 )\n , ( \"halvtredsindstyvende\", 50 )\n , ( \"tressende\", 60 )\n , ( \"tresindstyvende\", 60 )\n , ( \"halvfjerdsende\", 70 )\n , ( \"halvfjerdsindstyvende\", 70 )\n , ( \"firsende\", 80 )\n , ( \"firsindsstyvende\", 80 )\n , ( \"halvfemsende\", 90 )\n , ( \"halvfemsindstyvende\", 90 )\n ]\n\noneValMap :: HashMap Text Int\noneValMap = HashMap.fromList\n [ ( \"\", 0 )\n , ( \"enog\", 1 )\n , ( \"toog\", 2 )\n , ( \"treog\", 3 )\n , ( \"fireog\", 4 )\n , ( \"femog\", 5 )\n , ( \"seksog\", 6 )\n , ( \"syvog\", 7 )\n , ( \"otteog\", 8 )\n , ( \"niog\", 9 )\n ]\n\nruleOrdinalsFirstst :: Rule\nruleOrdinalsFirstst = Rule\n { name = \"ordinals (first..19st)\"\n , pattern =\n [ regex \"(f\u00c3\u00b8rste|anden|tredje|fjerde|femte|sjette|syvende|ottende|niende|tiende|elfte|tolvte|trettende|fjortende|femtende|sekstende|syttende|attende|nittende)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n ordinal <$> HashMap.lookup (Text.toLower match) ordinalsMap\n _ -> Nothing\n }\n\nruleSpelledOutOrdinals :: Rule\nruleSpelledOutOrdinals = Rule\n { name = \"ordinals, 20 to 99, spelled-out\"\n , pattern =\n [ regex (concat [\"((?:en|to|tre|fire|fem|seks|syv|otte|ni)og)?\",\n \"(tyvende\",\n \"|tredivte\",\n \"|fyrr(?:etyv)?ende\",\n \"|halvtreds(?:indstyv)?ende\",\n \"|tres(?:indstyv|s)?ende\",\n \"|halvfjerds(?:indstyv)?ende\",\n \"|firs(?:indstyv)?ende\",\n \"|halvfems(?:indstyv)?ende)\"])\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (ones:tens:_)):_) -> do\n oneVal <- HashMap.lookup (Text.toLower ones) oneValMap\n tenVal <- HashMap.lookup (Text.toLower tens) cardinalsMap\n Just $ ordinal (oneVal + tenVal)\n _ -> Nothing\n\n }\n\nruleSpelledOutBigOrdinals :: Rule\nruleSpelledOutBigOrdinals = Rule\n { name = \"ordinals, above 99, spelled out\"\n , pattern =\n [ numberWith TNumeral.value (> 99)\n , regex \"og\"\n , dimension Ordinal\n ]\n , prod = \\case\n Token Numeral NumeralData {TNumeral.value=maybenumnum}:_:Token Ordinal (OrdinalData ordnum):_ ->\n case getIntValue maybenumnum of\n Just numnum -> Just $ ordinal (numnum + ordnum)\n Nothing -> Nothing\n _ -> Nothing\n }\n\nruleOrdinalDigits :: Rule\nruleOrdinalDigits = Rule\n { name = \"ordinal (digits)\"\n , pattern =\n [ regex \"0*(\\\\d+)(\\\\.|ste?)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> do\n v <- parseInt match\n Just $ ordinal v\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleOrdinalDigits\n , ruleOrdinalsFirstst\n , ruleSpelledOutOrdinals\n , ruleSpelledOutBigOrdinals\n ]\n", "num_lines": 170} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Ordinal.DE.Corpus\n ( corpus\n , negativeCorpus\n ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Locale\nimport Duckling.Ordinal.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale DE Nothing}, testOptions, allExamples)\n\nnegativeCorpus :: NegativeCorpus\nnegativeCorpus = (testContext {locale = makeLocale DE Nothing}, testOptions, examples)\n where\n examples =\n [ \"1.1\"\n , \"1.1.\"\n ]\n\nallExamples :: [Example]\nallExamples =\n examples (OrdinalData 4)\n [ \"vierter\"\n , \"4ter\"\n , \"Vierter\"\n , \"4.\"\n ]\n", "num_lines": 42} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Ordinal.DE.Rules\n ( rules\n ) where\n\nimport Data.Semigroup ((<>))\nimport Prelude\nimport Data.String\nimport Data.Text (Text)\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.List as List\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers (parseInt)\nimport Duckling.Ordinal.Helpers\nimport Duckling.Regex.Types\nimport Duckling.Types\n\nordinalList :: [(Text, Int)]\nordinalList =\n [ (\"erste\", 1)\n , (\"zweite\", 2)\n , (\"dritte\", 3)\n , (\"vierte\", 4)\n , (\"f\u00c3\u00bcnfte\", 5)\n , (\"sechste\", 6)\n , (\"siebte\", 7)\n , (\"achte\", 8)\n , (\"neunte\", 9)\n , (\"zehnte\", 10)\n , (\"elfte\", 11)\n , (\"zw\u00c3\u00b6lfte\", 12)\n , (\"dreizente\", 13)\n , (\"vierzehnte\", 14)\n , (\"f\u00c3\u00bcnfzehnte\", 15)\n , (\"sechzente\", 16)\n , (\"siebzehnte\", 17)\n , (\"achtzehnte\", 18)\n , (\"neunzehnte\", 19)\n , (\"zwanzigste\", 20)\n , (\"einundzwanzigste\", 21)\n , (\"zweiundzwanzigste\", 22)\n , (\"dreiundzwanzigste\", 23)\n , (\"vierundzwanzigste\", 24)\n , (\"f\u00c3\u00bcnfundzwanzigste\", 25)\n , (\"sechsundzwanzigste\", 26)\n , (\"siebenundzwanzigste\", 27)\n , (\"achtundzwanzigste\", 28)\n , (\"neunundzwanzigste\", 29)\n , (\"dreissigste\", 30)\n , (\"drei\u00c3\u0178igste\", 30)\n , (\"einunddreissigste\", 31)\n , (\"einunddrei\u00c3\u0178igste\", 31)\n ]\n\nruleOrdinalsFirstth :: Rule\nruleOrdinalsFirstth = Rule\n { name = \"ordinal (1..31)\"\n , pattern =\n [ regex $ Text.unpack construction\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n ordinal <$> HashMap.lookup (Text.toLower match) ordinalMap\n _ -> Nothing\n }\n where\n ordinalMap :: HashMap.HashMap Text Int\n ordinalMap = HashMap.fromList ordinalList\n\n construction :: Text\n construction =\n \"(\"\n <> mconcat (List.intersperse \"|\" (fst <$> ordinalList))\n <> \")[rsn]?\"\n\nruleOrdinalDigits :: Rule\nruleOrdinalDigits = Rule\n { name = \"ordinal (digits)\"\n , pattern =\n [ regex \"(? do\n v <- parseInt match\n Just $ ordinal v\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleOrdinalsFirstth\n , ruleOrdinalDigits\n ]\n", "num_lines": 106} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Ordinal.EN.Corpus\n ( corpus\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Ordinal.Types\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (OrdinalData 1)\n [ \"first\"\n , \"1st\"\n ]\n , examples (OrdinalData 2)\n [ \"second\"\n , \"2nd\"\n ]\n , examples (OrdinalData 3)\n [ \"third\"\n , \"3rd\"\n ]\n , examples (OrdinalData 4)\n [ \"fourth\"\n , \"4th\"\n ]\n , examples (OrdinalData 8)\n [ \"eighth\"\n , \"8th\"\n ]\n , examples (OrdinalData 25)\n [ \"twenty-fifth\"\n , \"twenty\u00e2\u20ac\u201dfifth\"\n , \"twenty fifth\"\n , \"twentyfifth\"\n , \"25th\"\n ]\n , examples (OrdinalData 31)\n [ \"thirty-first\"\n , \"thirty\u00e2\u20ac\u201dfirst\"\n , \"thirty first\"\n , \"thirtyfirst\"\n , \"31st\"\n ]\n , examples (OrdinalData 42)\n [ \"forty-second\"\n , \"forty\u00e2\u20ac\u201dsecond\"\n , \"forty second\"\n , \"fortysecond\"\n , \"42nd\"\n ]\n , examples (OrdinalData 73)\n [ \"seventy-third\"\n , \"seventy\u00e2\u20ac\u201dthird\"\n , \"seventy third\"\n , \"seventythird\"\n , \"73rd\"\n ]\n , examples (OrdinalData 90)\n [ \"ninetieth\"\n , \"90th\"\n ]\n ]\n", "num_lines": 78} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n{-# LANGUAGE NoRebindableSyntax #-}\n\nmodule Duckling.Ordinal.EN.Rules\n ( rules\n ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers (parseInt)\nimport Duckling.Ordinal.Helpers\nimport Duckling.Regex.Types\nimport Duckling.Types\n\nordinalsMap :: HashMap Text Int\nordinalsMap = HashMap.fromList\n [ ( \"first\", 1 )\n , ( \"second\", 2 )\n , ( \"third\", 3 )\n , ( \"fourth\", 4 )\n , ( \"fifth\", 5 )\n , ( \"sixth\", 6 )\n , ( \"seventh\", 7 )\n , ( \"eighth\", 8 )\n , ( \"ninth\", 9 )\n , ( \"tenth\", 10 )\n , ( \"eleventh\", 11 )\n , ( \"twelfth\", 12 )\n , ( \"thirteenth\", 13 )\n , ( \"fourteenth\", 14 )\n , ( \"fifteenth\", 15 )\n , ( \"sixteenth\", 16 )\n , ( \"seventeenth\", 17 )\n , ( \"eighteenth\", 18 )\n , ( \"nineteenth\", 19 )\n , ( \"twentieth\", 20 )\n , ( \"thirtieth\", 30 )\n , ( \"fortieth\", 40 )\n , ( \"fiftieth\", 50 )\n , ( \"sixtieth\", 60 )\n , ( \"seventieth\", 70 )\n , ( \"eightieth\", 80 )\n , ( \"ninetieth\", 90 )\n ]\n\ncardinalsMap :: HashMap Text Int\ncardinalsMap = HashMap.fromList\n [ ( \"twenty\", 20 )\n , ( \"thirty\", 30 )\n , ( \"forty\", 40 )\n , ( \"fifty\", 50 )\n , ( \"sixty\", 60 )\n , ( \"seventy\", 70 )\n , ( \"eighty\", 80 )\n , ( \"ninety\", 90 )\n ]\n\nruleOrdinals :: Rule\nruleOrdinals = Rule\n { name = \"ordinals (first..twentieth,thirtieth,...)\"\n , pattern = [regex \"(first|second|third|fourth|fifth|sixth|seventh|eighth|ninth|tenth|eleventh|twelfth|thirteenth|fourteenth|fifteenth|sixteenth|seventeenth|eighteenth|nineteenth|twentieth|thirtieth|fortieth|fiftieth|sixtieth|seventieth|eightieth|ninetieth)\"]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n ordinal <$> HashMap.lookup (Text.toLower match) ordinalsMap\n _ -> Nothing\n }\n\nruleCompositeOrdinals :: Rule\nruleCompositeOrdinals = Rule\n { name = \"ordinals (composite, e.g. eighty-seven, forty\u00e2\u20ac\u201dseventh, twenty ninth, thirtythird)\"\n , pattern = [regex \"(twenty|thirty|forty|fifty|sixty|seventy|eighty|ninety)[\\\\s\\\\-\\\\\u00e2\u20ac\u201d]?(first|second|third|fourth|fifth|sixth|seventh|eighth|ninth)\"]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (tens:units:_)):_) -> do\n tt <- HashMap.lookup (Text.toLower tens) cardinalsMap\n uu <- HashMap.lookup (Text.toLower units) ordinalsMap\n Just (ordinal (tt + uu))\n _ -> Nothing\n }\n\nruleOrdinalDigits :: Rule\nruleOrdinalDigits = Rule\n { name = \"ordinal (digits)\"\n , pattern = [regex \"0*(\\\\d+) ?(st|nd|rd|th)\"]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> ordinal <$> parseInt match\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleOrdinals\n , ruleCompositeOrdinals\n , ruleOrdinalDigits\n ]\n", "num_lines": 109} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Ordinal.ES.Corpus\n ( corpus ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Locale\nimport Duckling.Ordinal.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale ES Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (OrdinalData 1)\n [ \"primer\"\n , \"primero\"\n , \"primeras\"\n ]\n , examples (OrdinalData 2)\n [ \"segundo\"\n , \"segunda\"\n , \"segundos\"\n ]\n , examples (OrdinalData 3)\n [ \"tercero\"\n , \"tercera\"\n , \"terceros\"\n ]\n , examples (OrdinalData 10)\n [ \"decimo\"\n , \"decimas\"\n , \"d\u00c3\u00a9cimos\"\n ]\n ]\n", "num_lines": 47} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Ordinal.ES.Rules\n ( rules ) where\n\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\nimport Prelude\nimport Data.String\n\nimport Duckling.Dimensions.Types\nimport Duckling.Ordinal.Helpers\nimport Duckling.Regex.Types\nimport Duckling.Types\n\nordinalsMap :: HashMap.HashMap Text.Text Int\nordinalsMap = HashMap.fromList\n [ ( \"primer\" , 1 )\n , ( \"primero\" , 1 )\n , ( \"primeros\" , 1 )\n , ( \"primera\" , 1 )\n , ( \"primeras\" , 1 )\n , ( \"segundo\" , 2 )\n , ( \"segunda\" , 2 )\n , ( \"segundas\" , 2 )\n , ( \"segundos\" , 2 )\n , ( \"terceros\" , 3 )\n , ( \"tercera\" , 3 )\n , ( \"terceras\" , 3 )\n , ( \"tercero\" , 3 )\n , ( \"tercer\" , 3 )\n , ( \"cuarta\" , 4 )\n , ( \"cuartas\" , 4 )\n , ( \"cuartos\" , 4 )\n , ( \"cuarto\" , 4 )\n , ( \"quinto\" , 5 )\n , ( \"quinta\" , 5 )\n , ( \"quintas\" , 5 )\n , ( \"quintos\" , 5 )\n , ( \"sextos\" , 6 )\n , ( \"sexto\" , 6 )\n , ( \"sexta\" , 6 )\n , ( \"sextas\" , 6 )\n , ( \"s\u00c3\u00a9ptimas\" , 7 )\n , ( \"septimas\" , 7 )\n , ( \"s\u00c3\u00a9ptima\" , 7 )\n , ( \"septimos\" , 7 )\n , ( \"septima\" , 7 )\n , ( \"s\u00c3\u00a9ptimo\" , 7 )\n , ( \"s\u00c3\u00a9ptimos\" , 7 )\n , ( \"septimo\" , 7 )\n , ( \"octavas\" , 8 )\n , ( \"octavo\" , 8 )\n , ( \"octavos\" , 8 )\n , ( \"octava\" , 8 )\n , ( \"novenos\" , 9 )\n , ( \"novena\" , 9 )\n , ( \"noveno\" , 9 )\n , ( \"novenas\" , 9 )\n , ( \"d\u00c3\u00a9cimos\" , 10 )\n , ( \"decimo\" , 10 )\n , ( \"decimos\" , 10 )\n , ( \"d\u00c3\u00a9cimo\" , 10 )\n , ( \"decimas\" , 10 )\n , ( \"d\u00c3\u00a9cima\" , 10 )\n , ( \"decima\" , 10 )\n , ( \"d\u00c3\u00a9cimas\" , 10 )\n ]\n\nruleOrdinalsPrimero :: Rule\nruleOrdinalsPrimero = Rule\n { name = \"ordinals (primero..10)\"\n , pattern =\n [ regex \"((primer|segund|tercer|cuart|quint|sext|s[e\u00c3\u00a9]ptim|octav|noven|d[e\u00c3\u00a9]cim)(os?|as?)|(prim|terc)er)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n ordinal <$> HashMap.lookup (Text.toLower match) ordinalsMap\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleOrdinalsPrimero\n ]\n", "num_lines": 94} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Ordinal.ET.Corpus\n ( corpus ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Locale\nimport Duckling.Ordinal.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale ET Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples =\n examples (OrdinalData 4)\n [ \"4.\"\n , \"neljas\"\n , \"Neljas\"\n ]\n", "num_lines": 31} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Ordinal.ET.Rules\n ( rules ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers (parseInt)\nimport Duckling.Ordinal.Helpers\nimport Duckling.Regex.Types\nimport Duckling.Types\n\nordinalsMap :: HashMap Text Int\nordinalsMap = HashMap.fromList\n [ (\"esimene\", 1)\n , (\"teine\", 2)\n , (\"kolmas\", 3)\n , (\"neljas\", 4)\n , (\"viies\", 5)\n , (\"kuues\", 6)\n , (\"seitsmes\", 7)\n , (\"kaheksas\", 8)\n , (\"\u00c3\u00bcheksas\", 9)\n , (\"k\u00c3\u00bcmnes\", 10)\n , (\"\u00c3\u00bcheteistk\u00c3\u00bcmnes\", 11)\n , (\"kaheteistk\u00c3\u00bcmnes\", 12)\n , (\"kolmeteistk\u00c3\u00bcmnes\", 13)\n , (\"neljateistk\u00c3\u00bcmnes\", 14)\n , (\"viieteistk\u00c3\u00bcmnes\", 15)\n , (\"kuueteistk\u00c3\u00bcmnes\", 16)\n , (\"seitsmeteistk\u00c3\u00bcmnes\", 17)\n , (\"kaheksateistk\u00c3\u00bcmnes\", 18)\n , (\"\u00c3\u00bcheksateistk\u00c3\u00bcmnes\", 19)\n ]\n\nruleOrdinalsFirstth :: Rule\nruleOrdinalsFirstth = Rule\n { name = \"ordinals (first..19th)\"\n , pattern =\n [ regex \"(esimene|teine|kolmas|neljas|viies|kuues|seitsmes|kaheksas|\u00c3\u00bcheksas|k\u00c3\u00bcmnes|\u00c3\u00bcheteistk\u00c3\u00bcmnes|kaheteistk\u00c3\u00bcmnes|kolmeteistk\u00c3\u00bcmnes|neljateistk\u00c3\u00bcmnes|viieteistk\u00c3\u00bcmnes|kuueteistk\u00c3\u00bcmnes|seitsmeteistk\u00c3\u00bcmnes|kaheksateistk\u00c3\u00bcmnes|\u00c3\u00bcheksateistk\u00c3\u00bcmnes)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n ordinal <$> HashMap.lookup (Text.toLower match) ordinalsMap\n _ -> Nothing\n }\n\nruleOrdinalDigits :: Rule\nruleOrdinalDigits = Rule\n { name = \"ordinal (digits)\"\n , pattern =\n [ regex \"0*(\\\\d+)\\\\.\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> ordinal <$> parseInt match\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleOrdinalDigits\n , ruleOrdinalsFirstth\n ]\n", "num_lines": 78} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Ordinal.FR.Corpus\n ( corpus ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Locale\nimport Duckling.Ordinal.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale FR Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (OrdinalData 1)\n [ \"1er\"\n , \"1ere\"\n , \"1\u00c3\u00a8re\"\n , \"Premier\"\n , \"premi\u00c3\u00a8re\"\n ]\n , examples (OrdinalData 2)\n [ \"deuxieme\"\n , \"deuxi\u00c3\u00a8me\"\n , \"2e\"\n , \"second\"\n , \"2eme\"\n , \"2\u00c3\u00a8me\"\n ]\n , examples (OrdinalData 11)\n [ \"onzieme\"\n , \"onzi\u00c3\u00a8me\"\n , \"11eme\"\n , \"11\u00c3\u00a8me\"\n , \"11e\"\n ]\n ]\n", "num_lines": 49} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Ordinal.FR.Rules\n ( rules\n ) where\n\nimport Data.HashMap.Strict ( HashMap)\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers (parseInt)\nimport Duckling.Ordinal.Helpers\nimport Duckling.Regex.Types (GroupMatch (..))\nimport Duckling.Types\n\nordinalsMap :: HashMap Text Int\nordinalsMap = HashMap.fromList\n [ ( \"premi\u00c3\u00a8re\", 1 )\n , ( \"premiere\", 1 )\n , ( \"premier\", 1 )\n , ( \"deuxi\u00c3\u00a8me\", 2 )\n , ( \"deuxieme\", 2 )\n , ( \"second\", 2 )\n , ( \"seconde\", 2 )\n , ( \"troisi\u00c3\u00a8me\", 3 )\n , ( \"troisieme\", 3 )\n , ( \"quatrieme\", 4 )\n , ( \"quatri\u00c3\u00a8me\", 4 )\n , ( \"cinquieme\", 5 )\n , ( \"cinqui\u00c3\u00a8me\", 5 )\n , ( \"sixi\u00c3\u00a8me\", 6 )\n , ( \"sixieme\", 6 )\n , ( \"septieme\", 7 )\n , ( \"septi\u00c3\u00a8me\", 7 )\n , ( \"huiti\u00c3\u00a8me\", 8 )\n , ( \"huitieme\", 8 )\n , ( \"neuvieme\", 9 )\n , ( \"neuvi\u00c3\u00a8me\", 9 )\n , ( \"dixi\u00c3\u00a8me\", 10 )\n , ( \"dixieme\", 10 )\n , ( \"onzi\u00c3\u00a8me\", 11 )\n , ( \"onzieme\", 11 )\n , ( \"douzieme\", 12 )\n , ( \"douzi\u00c3\u00a8me\", 12 )\n , ( \"treizieme\", 13 )\n , ( \"treizi\u00c3\u00a8me\", 13 )\n , ( \"quatorzi\u00c3\u00a8me\", 14 )\n , ( \"quatorzieme\", 14 )\n , ( \"quinzi\u00c3\u00a8me\", 15 )\n , ( \"quinzieme\", 15 )\n , ( \"seizieme\", 16 )\n , ( \"seizi\u00c3\u00a8me\", 16 )\n ]\n\nruleOrdinalsPremierseizieme :: Rule\nruleOrdinalsPremierseizieme = Rule\n { name = \"ordinals (premier..seizieme)\"\n , pattern =\n [ regex \"(premi(ere?|\u00c3\u00a8re)|(deux|trois|quatr|cinqu|six|sept|huit|neuv|dix|onz|douz|treiz|quatorz|quinz|seiz)i(e|\u00c3\u00a8)me|seconde?)\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n ordinal <$> HashMap.lookup (Text.toLower match) ordinalsMap\n _ -> Nothing\n }\n\nruleOrdinalDigits :: Rule\nruleOrdinalDigits = Rule\n { name = \"ordinal (digits)\"\n , pattern =\n [ regex \"0*(\\\\d+) ?(ere?|\u00c3\u00a8re|\u00c3\u00a8me|eme|e)\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):_) -> ordinal <$> parseInt match\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleOrdinalDigits\n , ruleOrdinalsPremierseizieme\n ]\n", "num_lines": 96} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Ordinal.GA.Corpus\n ( corpus ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Locale\nimport Duckling.Ordinal.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale GA Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (OrdinalData 6)\n [ \"s\u00c3\u00a9u\"\n , \"6a\"\n , \"6d\"\n , \"06u\"\n , \"6 \u00c3\u00ba\"\n , \"0006 adh\"\n ]\n , examples (OrdinalData 1)\n [ \"chead\"\n , \"t-aonu\"\n , \"t-aon\u00c3\u00ba\"\n , \"Aonu\"\n , \"aon\u00c3\u00ba\"\n ]\n , examples (OrdinalData 30)\n [ \"tr\u00c3\u00adochad\u00c3\u00ba\"\n , \"triochad\u00c3\u00ba\"\n , \"tr\u00c3\u00adochadu\"\n ]\n , examples (OrdinalData 50)\n [ \"caogadu\"\n , \"caogad\u00c3\u00ba\"\n ]\n ]\n", "num_lines": 51} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Ordinal.GA.Rules\n ( rules ) where\n\nimport qualified Data.Text as Text\nimport Prelude\nimport Data.String\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers (parseInt)\nimport Duckling.Ordinal.Helpers\nimport Duckling.Regex.Types\nimport Duckling.Types\n\nruleOrdinalsChadDaraEtc :: Rule\nruleOrdinalsChadDaraEtc = Rule\n { name = \"ordinals (ch\u00c3\u00a9ad, dara, etc.)\"\n , pattern =\n [ regex \"(ch(\u00c3\u00a9|e)ad|aon(\u00c3\u00ba|u)|t-aon(\u00c3\u00ba|u)|dara|tr(\u00c3\u00ad|i)(\u00c3\u00ba|u)|ceathr(\u00c3\u00ba|u)|c(\u00c3\u00ba|u)igi(\u00c3\u00ba|u)|s(\u00c3\u00a9|e)(\u00c3\u00ba|u)|seacht(\u00c3\u00ba|u)|ocht(\u00c3\u00ba|u)|t-ocht(\u00c3\u00ba|u)|nao(\u00c3\u00ba|u)|deichi(\u00c3\u00ba|u)|fichi(\u00c3\u00ba|u)|tr(\u00c3\u00ad|i)ochad(\u00c3\u00ba|u)|daichead(\u00c3\u00ba|u)|caogad(\u00c3\u00ba|u)|seascad(\u00c3\u00ba|u)|seacht(\u00c3\u00b3|o)d(\u00c3\u00ba|u)|ocht(\u00c3\u00b3|o)d(\u00c3\u00ba|u)|t-ocht(\u00c3\u00b3|o)d(\u00c3\u00ba|u)|n(\u00c3\u00b3|o)chad(\u00c3\u00ba|u)|c(\u00c3\u00a9|e)ad(\u00c3\u00ba|u)|mili(\u00c3\u00ba|u)|milli(\u00c3\u00ba|u)n(\u00c3\u00ba|u))\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of\n \"t-aonu\" -> Just $ ordinal 1\n \"aonu\" -> Just $ ordinal 1\n \"aon\u00c3\u00ba\" -> Just $ ordinal 1\n \"ch\u00c3\u00a9ad\" -> Just $ ordinal 1\n \"chead\" -> Just $ ordinal 1\n \"t-aon\u00c3\u00ba\" -> Just $ ordinal 1\n \"dara\" -> Just $ ordinal 2\n \"tri\u00c3\u00ba\" -> Just $ ordinal 3\n \"tr\u00c3\u00adu\" -> Just $ ordinal 3\n \"tr\u00c3\u00ad\u00c3\u00ba\" -> Just $ ordinal 3\n \"triu\" -> Just $ ordinal 3\n \"ceathr\u00c3\u00ba\" -> Just $ ordinal 4\n \"ceathru\" -> Just $ ordinal 4\n \"c\u00c3\u00baigiu\" -> Just $ ordinal 5\n \"c\u00c3\u00baigi\u00c3\u00ba\" -> Just $ ordinal 5\n \"cuigiu\" -> Just $ ordinal 5\n \"cuigi\u00c3\u00ba\" -> Just $ ordinal 5\n \"s\u00c3\u00a9u\" -> Just $ ordinal 6\n \"s\u00c3\u00a9\u00c3\u00ba\" -> Just $ ordinal 6\n \"seu\" -> Just $ ordinal 6\n \"se\u00c3\u00ba\" -> Just $ ordinal 6\n \"seachtu\" -> Just $ ordinal 7\n \"seacht\u00c3\u00ba\" -> Just $ ordinal 7\n \"t-ocht\u00c3\u00ba\" -> Just $ ordinal 8\n \"ochtu\" -> Just $ ordinal 8\n \"t-ochtu\" -> Just $ ordinal 8\n \"ocht\u00c3\u00ba\" -> Just $ ordinal 8\n \"naou\" -> Just $ ordinal 9\n \"nao\u00c3\u00ba\" -> Just $ ordinal 9\n \"deichiu\" -> Just $ ordinal 10\n \"deichi\u00c3\u00ba\" -> Just $ ordinal 10\n \"fichiu\" -> Just $ ordinal 20\n \"fichi\u00c3\u00ba\" -> Just $ ordinal 20\n \"tr\u00c3\u00adochadu\" -> Just $ ordinal 30\n \"triochadu\" -> Just $ ordinal 30\n \"tr\u00c3\u00adochad\u00c3\u00ba\" -> Just $ ordinal 30\n \"triochad\u00c3\u00ba\" -> Just $ ordinal 30\n \"daichead\u00c3\u00ba\" -> Just $ ordinal 40\n \"daicheadu\" -> Just $ ordinal 40\n \"caogadu\" -> Just $ ordinal 50\n \"caogad\u00c3\u00ba\" -> Just $ ordinal 50\n \"seascadu\" -> Just $ ordinal 60\n \"seascad\u00c3\u00ba\" -> Just $ ordinal 60\n \"seachtodu\" -> Just $ ordinal 70\n \"seachtod\u00c3\u00ba\" -> Just $ ordinal 70\n \"seacht\u00c3\u00b3d\u00c3\u00ba\" -> Just $ ordinal 70\n \"seacht\u00c3\u00b3du\" -> Just $ ordinal 70\n \"ocht\u00c3\u00b3du\" -> Just $ ordinal 80\n \"ochtodu\" -> Just $ ordinal 80\n \"t-ochtodu\" -> Just $ ordinal 80\n \"t-ocht\u00c3\u00b3d\u00c3\u00ba\" -> Just $ ordinal 80\n \"t-ochtod\u00c3\u00ba\" -> Just $ ordinal 80\n \"ocht\u00c3\u00b3d\u00c3\u00ba\" -> Just $ ordinal 80\n \"t-ocht\u00c3\u00b3du\" -> Just $ ordinal 80\n \"ochtod\u00c3\u00ba\" -> Just $ ordinal 80\n \"n\u00c3\u00b3chad\u00c3\u00ba\" -> Just $ ordinal 90\n \"n\u00c3\u00b3chadu\" -> Just $ ordinal 90\n \"nochad\u00c3\u00ba\" -> Just $ ordinal 90\n \"nochadu\" -> Just $ ordinal 90\n \"c\u00c3\u00a9ad\u00c3\u00ba\" -> Just $ ordinal 100\n \"cead\u00c3\u00ba\" -> Just $ ordinal 100\n \"ceadu\" -> Just $ ordinal 100\n \"c\u00c3\u00a9adu\" -> Just $ ordinal 100\n \"miliu\" -> Just $ ordinal 1000\n \"mili\u00c3\u00ba\" -> Just $ ordinal 1000\n \"milliun\u00c3\u00ba\" -> Just $ ordinal 1000000\n \"milliunu\" -> Just $ ordinal 1000000\n \"milli\u00c3\u00banu\" -> Just $ ordinal 1000000\n \"milli\u00c3\u00ban\u00c3\u00ba\" -> Just $ ordinal 1000000\n _ -> Nothing\n _ -> Nothing\n }\n\nruleOrdinalDigits :: Rule\nruleOrdinalDigits = Rule\n { name = \"ordinal (digits)\"\n , pattern =\n [ regex \"0*(\\\\d+) ?(adh|a|d|\u00c3\u00ba|u)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> ordinal <$> parseInt match\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleOrdinalDigits\n , ruleOrdinalsChadDaraEtc\n ]\n", "num_lines": 121} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Ordinal.HU.Corpus\n ( corpus ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Locale\nimport Duckling.Ordinal.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale HU Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (OrdinalData 1)\n [ \"els\u00c5\u2018\"\n , \"1.\"\n ]\n , examples (OrdinalData 2)\n [ \"m\u00c3\u00a1sodik\"\n , \"2.\"\n ]\n , examples (OrdinalData 3)\n [ \"harmadik\"\n , \"3.\"\n ]\n , examples (OrdinalData 4)\n [ \"negyedik\"\n , \"4.\"\n ]\n , examples (OrdinalData 8)\n [ \"nyolcadik\"\n , \"8.\"\n ]\n , examples (OrdinalData 25)\n [ \"huszon\u00c3\u00b6t\u00c3\u00b6dik\"\n , \"25.\"\n ]\n , examples (OrdinalData 31)\n [ \"harmincegyedik\"\n , \"31.\"\n ]\n , examples (OrdinalData 42)\n [ \"negyvenkettedik\"\n , \"42.\"\n ]\n , examples (OrdinalData 77)\n [ \"hetvenhetedik\"\n , \"77.\"\n ]\n , examples (OrdinalData 90)\n [ \"kilencvenedik\"\n , \"90.\"\n ]\n ]\n", "num_lines": 67} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Ordinal.HU.Rules\n ( rules ) where\n\nimport Control.Monad (join)\nimport Data.HashMap.Strict ( HashMap)\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers (parseInt)\nimport Duckling.Ordinal.Helpers\nimport Duckling.Regex.Types\nimport Duckling.Types\n\nordinalsMap :: HashMap Text Int\nordinalsMap = HashMap.fromList\n [ ( \"els\u00c5\u2018\", 1 )\n , ( \"m\u00c3\u00a1sodik\", 2 )\n , ( \"harmadik\", 3 )\n , ( \"negyedik\", 4 )\n , ( \"\u00c3\u00b6t\u00c3\u00b6dik\", 5 )\n , ( \"hatodik\", 6 )\n , ( \"hetedik\", 7 )\n , ( \"nyolcadik\", 8 )\n , ( \"kilencedik\", 9 )\n , ( \"tizedik\", 10 )\n , ( \"huszadik\", 20 )\n , ( \"harmincadik\", 30 )\n , ( \"negyvenedik\", 40 )\n , ( \"\u00c3\u00b6tvenedik\", 50 )\n , ( \"hatvanadik\", 60 )\n , ( \"hetvenedik\", 70 )\n , ( \"nyolcvanadik\", 80 )\n , ( \"kilencvenedik\", 90 )\n ]\n\nordinalsMap2 :: HashMap Text Int\nordinalsMap2 = HashMap.fromList\n [ ( \"egyedik\", 1 )\n , ( \"kettedik\", 2 )\n , ( \"harmadik\", 3 )\n , ( \"negyedik\", 4 )\n , ( \"\u00c3\u00b6t\u00c3\u00b6dik\", 5 )\n , ( \"hatodik\", 6 )\n , ( \"hetedik\", 7 )\n , ( \"nyolcadik\", 8 )\n , ( \"kilencedik\", 9 )\n ]\n\ncardinalsMap :: HashMap Text Int\ncardinalsMap = HashMap.fromList\n [ ( \"tizen\", 10 )\n , ( \"huszon\", 20 )\n , ( \"harminc\", 30 )\n , ( \"negyven\", 40 )\n , ( \"\u00c3\u00b6tven\", 50 )\n , ( \"hatvan\", 60 )\n , ( \"hetven\", 70 )\n , ( \"nyolcvan\", 80 )\n , ( \"kilencven\", 90 )\n ]\n\nruleOrdinals :: Rule\nruleOrdinals = Rule\n { name = \"ordinals (first..twentieth,thirtieth,...)\"\n , pattern =\n [ regex \"(els\u00c5\u2018|m\u00c3\u00a1sodik|harmadik|negyedik|\u00c3\u00b6t\u00c3\u00b6dik|hatodik|hetedik|nyolcadik|kilencedik|tizedik|huszadik|harmincadik|negyvenedik|\u00c3\u00b6tvenedik|hatvanadik|hetvenedik|nyolcvanadik|kilencvenedik)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n ordinal <$> HashMap.lookup (Text.toLower match) ordinalsMap\n _ -> Nothing\n }\n\nruleCompositeOrdinals :: Rule\nruleCompositeOrdinals = Rule\n { name = \"ordinals (composite, e.g., eighty-seven)\"\n , pattern =\n [ regex \"(tizen|huszon|harminc|negyven|\u00c3\u00b6tven|hatvan|hetven|nyolcvan|kilencven)\\\\-?(egyedik|kettedik|harmadik|negyedik|\u00c3\u00b6t\u00c3\u00b6dik|hatodik|hetedik|nyolcadik|kilencedik)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (tens:units:_)):_) -> do\n tt <- HashMap.lookup (Text.toLower tens) cardinalsMap\n uu <- HashMap.lookup (Text.toLower units) ordinalsMap2\n Just . ordinal $ tt + uu\n _ -> Nothing\n }\n\nruleOrdinalDigits :: Rule\nruleOrdinalDigits = Rule\n { name = \"ordinal (digits)\"\n , pattern =\n [ regex \"0*(\\\\d+)\\\\.\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> ordinal <$> parseInt match\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleOrdinals\n , ruleCompositeOrdinals\n , ruleOrdinalDigits\n ]\n", "num_lines": 119} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Ordinal.ID.Corpus\n ( corpus ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Locale\nimport Duckling.Ordinal.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale ID Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (OrdinalData 4)\n [ \"ke-4\"\n , \"keempat\"\n ]\n , examples (OrdinalData 10)\n [ \"Kesepuluh\"\n ]\n , examples (OrdinalData 3)\n [ \"ketiga\"\n , \"ke-00003\"\n ]\n ]\n", "num_lines": 38} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Ordinal.ID.Rules\n ( rules ) where\n\nimport qualified Data.Text as Text\nimport Prelude\nimport Data.String\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers (parseInt)\nimport Duckling.Ordinal.Helpers\nimport Duckling.Regex.Types\nimport Duckling.Types\n\nruleOrdinals :: Rule\nruleOrdinals = Rule\n { name = \"ordinals\"\n , pattern =\n [ regex \"(pertama|kedua|ketiga|keempat|kelima|keenam|ketujuh|kedelapan|kesembilan|kesepuluh)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of\n \"pertama\" -> Just $ ordinal 1\n \"kedua\" -> Just $ ordinal 2\n \"ketiga\" -> Just $ ordinal 3\n \"keempat\" -> Just $ ordinal 4\n \"kelima\" -> Just $ ordinal 5\n \"keenam\" -> Just $ ordinal 6\n \"ketujuh\" -> Just $ ordinal 7\n \"kedelapan\" -> Just $ ordinal 8\n \"kesembilan\" -> Just $ ordinal 9\n \"kesepuluh\" -> Just $ ordinal 10\n _ -> Nothing\n _ -> Nothing\n }\n\nruleOrdinalsDigits :: Rule\nruleOrdinalsDigits = Rule\n { name = \"ordinals (digits)\"\n , pattern =\n [ regex \"ke-0*(\\\\d+)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> ordinal <$> parseInt match\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleOrdinals\n , ruleOrdinalsDigits\n ]\n", "num_lines": 62} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Ordinal.IT.Corpus\n ( corpus ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Locale\nimport Duckling.Ordinal.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale IT Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (OrdinalData 1)\n [ \"primo\"\n , \"prima\"\n , \"1\u00c2\u00b0\"\n , \"1\u00c2\u00aa\"\n ]\n , examples (OrdinalData 2)\n [ \"secondo\"\n , \"seconda\"\n , \"2\u00c2\u00b0\"\n , \"2\u00c2\u00aa\"\n ]\n , examples (OrdinalData 3)\n [ \"terzo\"\n , \"Terza\"\n , \"3\u00c2\u00b0\"\n , \"3\u00c2\u00aa\"\n ]\n , examples (OrdinalData 4)\n [ \"quarto\"\n , \"quarta\"\n , \"4\u00c2\u00b0\"\n , \"4\u00c2\u00aa\"\n ]\n , examples (OrdinalData 5)\n [ \"quinto\"\n , \"quinta\"\n , \"5\u00c2\u00b0\"\n , \"5\u00c2\u00aa\"\n ]\n , examples (OrdinalData 6)\n [ \"sesto\"\n , \"sesta\"\n , \"6\u00c2\u00b0\"\n , \"6\u00c2\u00aa\"\n ]\n , examples (OrdinalData 7)\n [ \"settimo\"\n , \"settima\"\n , \"7\u00c2\u00b0\"\n , \"7\u00c2\u00aa\"\n ]\n , examples (OrdinalData 8)\n [ \"ottavo\"\n , \"ottava\"\n , \"8\u00c2\u00b0\"\n , \"8\u00c2\u00aa\"\n ]\n , examples (OrdinalData 9)\n [ \"nono\"\n , \"nona\"\n , \"9\u00c2\u00b0\"\n , \"9\u00c2\u00aa\"\n ]\n , examples (OrdinalData 10)\n [ \"decimo\"\n , \"decima\"\n , \"10\u00c2\u00b0\"\n , \"10\u00c2\u00aa\"\n ]\n ]\n", "num_lines": 87} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Ordinal.IT.Rules\n ( rules ) where\n\nimport qualified Data.Text as Text\nimport Prelude\nimport Data.String\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers (parseInt)\nimport Duckling.Ordinal.Helpers\nimport Duckling.Regex.Types\nimport Duckling.Types\n\nruleOrdinalsPrimo :: Rule\nruleOrdinalsPrimo = Rule\n { name = \"ordinals (primo..10)\"\n , pattern =\n [ regex \"((prim|second|terz|quart|quint|sest|settim|ottav|non|decim)(o|a|i|e))\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of\n \"primi\" -> Just $ ordinal 1\n \"prima\" -> Just $ ordinal 1\n \"primo\" -> Just $ ordinal 1\n \"prime\" -> Just $ ordinal 1\n \"seconda\" -> Just $ ordinal 2\n \"secondi\" -> Just $ ordinal 2\n \"seconde\" -> Just $ ordinal 2\n \"secondo\" -> Just $ ordinal 2\n \"terze\" -> Just $ ordinal 3\n \"terzi\" -> Just $ ordinal 3\n \"terzo\" -> Just $ ordinal 3\n \"terza\" -> Just $ ordinal 3\n \"quarte\" -> Just $ ordinal 4\n \"quarto\" -> Just $ ordinal 4\n \"quarta\" -> Just $ ordinal 4\n \"quarti\" -> Just $ ordinal 4\n \"quinto\" -> Just $ ordinal 5\n \"quinta\" -> Just $ ordinal 5\n \"quinti\" -> Just $ ordinal 5\n \"quinte\" -> Just $ ordinal 5\n \"sesti\" -> Just $ ordinal 6\n \"seste\" -> Just $ ordinal 6\n \"sesta\" -> Just $ ordinal 6\n \"sesto\" -> Just $ ordinal 6\n \"settimi\" -> Just $ ordinal 7\n \"settima\" -> Just $ ordinal 7\n \"settimo\" -> Just $ ordinal 7\n \"settime\" -> Just $ ordinal 7\n \"ottavo\" -> Just $ ordinal 8\n \"ottava\" -> Just $ ordinal 8\n \"ottavi\" -> Just $ ordinal 8\n \"ottave\" -> Just $ ordinal 8\n \"none\" -> Just $ ordinal 9\n \"noni\" -> Just $ ordinal 9\n \"nona\" -> Just $ ordinal 9\n \"nono\" -> Just $ ordinal 9\n \"decimo\" -> Just $ ordinal 10\n \"decima\" -> Just $ ordinal 10\n \"decime\" -> Just $ ordinal 10\n \"decimi\" -> Just $ ordinal 10\n _ -> Nothing\n _ -> Nothing\n }\n\nruleOrdinalDigits :: Rule\nruleOrdinalDigits = Rule\n { name = \"ordinal (digits)\"\n , pattern =\n [ regex \"0*(\\\\d+) ?(\u00c2\u00aa|\u00c2\u00b0|\u00c2\u00b0)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> ordinal <$> parseInt match\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleOrdinalDigits\n , ruleOrdinalsPrimo\n ]\n", "num_lines": 92} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Ordinal.JA.Corpus\n ( corpus ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Locale\nimport Duckling.Ordinal.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale JA Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples =\n examples (OrdinalData 7)\n [ \"\u00e7\u00ac\u00ac\u00e4\u00b8\u0192\"\n ]\n", "num_lines": 29} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Ordinal.JA.Rules\n ( rules ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Types (NumeralData (..))\nimport qualified Duckling.Numeral.Types as TNumeral\nimport Duckling.Ordinal.Helpers\nimport Duckling.Types\n\nruleOrdinalDigits :: Rule\nruleOrdinalDigits = Rule\n { name = \"ordinal (digits)\"\n , pattern =\n [ regex \"\u00e7\u00ac\u00ac\"\n , dimension Numeral\n ]\n , prod = \\tokens -> case tokens of\n (_:Token Numeral NumeralData{TNumeral.value = v}:_) ->\n Just . ordinal $ floor v\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleOrdinalDigits\n ]\n", "num_lines": 40} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Ordinal.KM.Corpus\n ( corpus\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Locale\nimport Duckling.Ordinal.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncontext :: Context\ncontext = testContext{locale = makeLocale KM Nothing}\n\ncorpus :: Corpus\ncorpus = (context, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (OrdinalData 1)\n [ \"\u00e1\u017e\u2018\u00e1\u017e\u00b8\u00e1\u017e\u02dc\u00e1\u017e\u00bd\u00e1\u017e\u2122\"\n , \"\u00e1\u017e\u2018\u00e1\u017e\u00b8\u00e1\u0178\u00a1\"\n ]\n , examples (OrdinalData 400)\n [ \"\u00e1\u017e\u2018\u00e1\u017e\u00b8\u00e1\u017e\u201d\u00e1\u017e\u00bd\u00e1\u017e\u201c\u00e1\u017e\u0161\u00e1\u017e\u2122\"\n ]\n ]\n", "num_lines": 38} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Ordinal.KM.Rules\n ( rules\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Types (NumeralData (..))\nimport Duckling.Ordinal.Helpers\nimport Duckling.Types\nimport qualified Duckling.Numeral.Types as TNumeral\n\nruleOrdinalDigits :: Rule\nruleOrdinalDigits = Rule\n { name = \"ordinal (digits)\"\n , pattern =\n [ regex \"\u00e1\u017e\u2018\u00e1\u017e\u00b8\"\n , dimension Numeral\n ]\n , prod = \\case\n (_:Token Numeral NumeralData{TNumeral.value = x}:_) ->\n Just . ordinal $ floor x\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleOrdinalDigits\n ]\n", "num_lines": 42} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Ordinal.KO.Rules\n ( rules ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Dimensions.Types\nimport Duckling.Ordinal.Helpers\nimport Duckling.Numeral.Types (NumeralData (..))\nimport qualified Duckling.Numeral.Types as TNumeral\nimport Duckling.Types\n\nruleOrdinals :: Rule\nruleOrdinals = Rule\n { name = \"ordinals (\u00ec\u00b2\u00ab\u00eb\u00b2\u02c6\u00ec\u00a7\u00b8)\"\n , pattern =\n [ dimension Numeral\n , regex \"\u00eb\u00b2\u02c6\u00ec\u00a7\u00b8|\u00ec\u00a7\u00b8(\u00eb\u00b2\u02c6)?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData{TNumeral.value = v}:_) ->\n Just . ordinal $ floor v\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleOrdinals\n ]\n", "num_lines": 40} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Ordinal.NB.Corpus\n ( corpus ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Locale\nimport Duckling.Ordinal.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale NB Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (OrdinalData 4)\n [ \"4.\"\n , \"fjerde\"\n , \"fJerde\"\n ]\n , examples (OrdinalData 15)\n [ \"15.\"\n , \"femtende\"\n ]\n , examples (OrdinalData 5)\n [ \"5.\"\n , \"femte\"\n ]\n ]\n", "num_lines": 40} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Ordinal.NB.Rules\n ( rules ) where\n\nimport qualified Data.Text as Text\nimport Prelude\nimport Data.String\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers (parseInt)\nimport Duckling.Ordinal.Helpers\nimport Duckling.Regex.Types\nimport Duckling.Types\n\nruleOrdinalsFirstst :: Rule\nruleOrdinalsFirstst = Rule\n { name = \"ordinals (first..31st)\"\n , pattern =\n [ regex \"(f\u00c3\u00b8rste|andre|tredje|fjerde|femtende|femte|sjette|syvende|\u00c3\u00a5ttende|niende|tiende|ellevte|tolvte|trettende|fjortende|sekstende|syttende|attende|nittende|tyvende|tjuende|enogtyvende|toogtyvende|treogtyvende|fireogtyvende|femogtyvende|seksogtyvende|syvogtyvende|\u00c3\u00a5tteogtyvende|niogtyvende|enogtjuende|toogtjuende|treogtjuende|fireogtjuende|femogtjuende|seksogtjuende|syvogtjuende|\u00c3\u00a5tteogtyvend|niogtjuende|tredefte|enogtredefte)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of\n \"f\u00c3\u00b8rste\" -> Just $ ordinal 1\n \"andre\" -> Just $ ordinal 2\n \"tredje\" -> Just $ ordinal 3\n \"fjerde\" -> Just $ ordinal 4\n \"femte\" -> Just $ ordinal 5\n \"sjette\" -> Just $ ordinal 6\n \"syvende\" -> Just $ ordinal 7\n \"\u00c3\u00a5ttende\" -> Just $ ordinal 8\n \"niende\" -> Just $ ordinal 9\n \"tiende\" -> Just $ ordinal 10\n \"ellevte\" -> Just $ ordinal 11\n \"tolvte\" -> Just $ ordinal 12\n \"trettende\" -> Just $ ordinal 13\n \"fjortende\" -> Just $ ordinal 14\n \"femtende\" -> Just $ ordinal 15\n \"sekstende\" -> Just $ ordinal 16\n \"syttende\" -> Just $ ordinal 17\n \"attende\" -> Just $ ordinal 18\n \"nittende\" -> Just $ ordinal 19\n \"tyvende\" -> Just $ ordinal 20\n \"tjuende\" -> Just $ ordinal 20\n \"enogtjuende\" -> Just $ ordinal 21\n \"enogtyvende\" -> Just $ ordinal 21\n \"toogtyvende\" -> Just $ ordinal 22\n \"toogtjuende\" -> Just $ ordinal 22\n \"treogtyvende\" -> Just $ ordinal 23\n \"treogtjuende\" -> Just $ ordinal 23\n \"fireogtjuende\" -> Just $ ordinal 24\n \"fireogtyvende\" -> Just $ ordinal 24\n \"femogtyvende\" -> Just $ ordinal 25\n \"femogtjuende\" -> Just $ ordinal 25\n \"seksogtjuende\" -> Just $ ordinal 26\n \"seksogtyvende\" -> Just $ ordinal 26\n \"syvogtyvende\" -> Just $ ordinal 27\n \"syvogtjuende\" -> Just $ ordinal 27\n \"\u00c3\u00a5tteogtyvende\" -> Just $ ordinal 28\n \"\u00c3\u00a5tteogtjuende\" -> Just $ ordinal 28\n \"niogtyvende\" -> Just $ ordinal 29\n \"niogtjuende\" -> Just $ ordinal 29\n \"tredefte\" -> Just $ ordinal 30\n \"enogtredefte\" -> Just $ ordinal 31\n _ -> Nothing\n _ -> Nothing\n }\n\nruleOrdinalDigits :: Rule\nruleOrdinalDigits = Rule\n { name = \"ordinal (digits)\"\n , pattern =\n [ regex \"0*(\\\\d+)(\\\\.|ste?)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> ordinal <$> parseInt match\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleOrdinalDigits\n , ruleOrdinalsFirstst\n ]\n", "num_lines": 93} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Ordinal.NL.Corpus\n ( corpus ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Locale\nimport Duckling.Ordinal.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale NL Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (OrdinalData 1)\n [ \"1ste\"\n , \"eerste\"\n ]\n , examples (OrdinalData 4)\n [ \"4de\"\n , \"vierde\"\n ]\n , examples (OrdinalData 17)\n [ \"Zeventiende\"\n , \"17de\"\n ]\n ]\n", "num_lines": 39} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Ordinal.NL.Rules\n ( rules ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport qualified Data.HashMap.Strict as HashMap\nimport Data.Text (Text)\nimport qualified Data.Text as Text\nimport Prelude\nimport Data.String\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers (parseInt)\nimport Duckling.Ordinal.Helpers\nimport Duckling.Regex.Types\nimport Duckling.Types\n\nzeroNineteenMap :: HashMap Text Int\nzeroNineteenMap = HashMap.fromList\n [ (\"eerste\", 1)\n , (\"tweede\", 2)\n , (\"derde\", 3)\n , (\"vierde\", 4)\n , (\"vijfde\", 5)\n , (\"zesde\", 6)\n , (\"zevende\", 7)\n , (\"achste\", 8)\n , (\"negende\", 9)\n , (\"tiende\", 10)\n , (\"elfde\", 11)\n , (\"twaalfde\", 12)\n , (\"dertiende\", 13)\n , (\"veertiende\", 14)\n , (\"vijftiende\", 15)\n , (\"zestiende\", 16)\n , (\"zeventiende\", 17)\n , (\"achttiende\", 18)\n , (\"negentiende\", 19)\n ]\n\nruleOrdinalsFirstth :: Rule\nruleOrdinalsFirstth = Rule\n { name = \"ordinals (first..19th)\"\n , pattern =\n [ regex \"(eerste|tweede|derde|vierde|vijfde|zeste|zevende|achtste|negende|tiende|elfde|twaalfde|veertiende|vijftiende|zestiende|zeventiende|achttiende|negentiende)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n ordinal <$> HashMap.lookup (Text.toLower match) zeroNineteenMap\n _ -> Nothing\n }\n\nruleOrdinalDigits :: Rule\nruleOrdinalDigits = Rule\n { name = \"ordinal (digits)\"\n , pattern =\n [ regex \"0*(\\\\d+)(\\\\.| ?(ste|de))\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n ordinal <$> parseInt match\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleOrdinalDigits\n , ruleOrdinalsFirstth\n ]\n", "num_lines": 79} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Ordinal.PL.Corpus\n ( corpus ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Locale\nimport Duckling.Ordinal.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale PL Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples =\n examples (OrdinalData 4)\n [ \"4ty\"\n , \"czwarty\"\n ]\n", "num_lines": 30} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Ordinal.PL.Rules\n ( rules ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers (parseInt)\nimport Duckling.Ordinal.Helpers\nimport Duckling.Ordinal.Types (OrdinalData (..))\nimport qualified Duckling.Ordinal.Types as TOrdinal\nimport Duckling.Regex.Types\nimport Duckling.Types\n\nruleThOrdinalNoSpace :: Rule\nruleThOrdinalNoSpace = Rule\n { name = \"24th ordinal no space\"\n , pattern =\n [ regex \"dwudziest(ym|y|ego|emu|(a|\u00c4\u2026)|ej)czwart(y|ego|emu|ym|(a|\u00c4\u2026)|ej)\"\n ]\n , prod = \\_ -> Just $ ordinal 24\n }\n\nruleThOrdinal16 :: Rule\nruleThOrdinal16 = Rule\n { name = \"31-39th ordinal\"\n , pattern =\n [ regex \"trzydziest(ym|y|ego|emu|(a|\u00c4\u2026)|ej)( |-)?\"\n , dimension Ordinal\n ]\n , prod = \\tokens -> case tokens of\n (_:Token Ordinal OrdinalData{TOrdinal.value = v}:_) ->\n Just . ordinal $ 30 + v\n _ -> Nothing\n }\n\nruleThOrdinal3 :: Rule\nruleThOrdinal3 = Rule\n { name = \"10th ordinal\"\n , pattern =\n [ regex \"dziesi(a|\u00c4\u2026)t(ym|y|ego|emu|(a|\u00c4\u2026)|ej)\"\n ]\n , prod = \\_ -> Just $ ordinal 10\n }\n\nruleOrdinalDigits :: Rule\nruleOrdinalDigits = Rule\n { name = \"ordinal (digits)\"\n , pattern =\n [ regex \"0*(\\\\d+)( |-)?(szy|sza|szym|ego|go|szego|gi(ego|ej)?|st(a|y|ej)|t(ej|y|ego)|ci(ego)?)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> ordinal <$> parseInt match\n _ -> Nothing\n }\n\nruleThOrdinal8 :: Rule\nruleThOrdinal8 = Rule\n { name = \"15th ordinal\"\n , pattern =\n [ regex \"pi(e|\u00c4\u2122)tnast(ym|y|ego|emu|(a|\u00c4\u2026)|ej)\"\n ]\n , prod = \\_ -> Just $ ordinal 15\n }\n\nruleThOrdinal13 :: Rule\nruleThOrdinal13 = Rule\n { name = \"20th ordinal\"\n , pattern =\n [ regex \"dwudziest(ym|y|ego|emu|(a|\u00c4\u2026)|ej)\"\n ]\n , prod = \\_ -> Just $ ordinal 20\n }\n\nruleThOrdinal4 :: Rule\nruleThOrdinal4 = Rule\n { name = \"11th ordinal\"\n , pattern =\n [ regex \"jedenast(ym|y|ego|emu|(a|\u00c4\u2026)|ej)\"\n ]\n , prod = \\_ -> Just $ ordinal 11\n }\n\nruleFifthOrdinal :: Rule\nruleFifthOrdinal = Rule\n { name = \"fifth ordinal\"\n , pattern =\n [ regex \"pi(a|\u00c4\u2026)t(y|ego|emu|m|(a|\u00c4\u2026)|ej)\"\n ]\n , prod = \\_ -> Just $ ordinal 5\n }\n\nruleThOrdinal11 :: Rule\nruleThOrdinal11 = Rule\n { name = \"18th ordinal\"\n , pattern =\n [ regex \"osiemnast(ym|y|ego|emu|(a|\u00c4\u2026)|ej)\"\n ]\n , prod = \\_ -> Just $ ordinal 18\n }\n\nruleSecondOrdinal :: Rule\nruleSecondOrdinal = Rule\n { name = \"second ordinal\"\n , pattern =\n [ regex \"drugi?(ego|emu|m|(a|\u00c4\u2026)|ej)?\"\n ]\n , prod = \\_ -> Just $ ordinal 2\n }\n\nruleNdOrdinalNoSpace :: Rule\nruleNdOrdinalNoSpace = Rule\n { name = \"22nd ordinal no space\"\n , pattern =\n [ regex \"dwudziest(ym|y|ego|emu|(a|\u00c4\u2026)|ej)drugi?(ego|emu|m|(a|\u00c4\u2026)|ej)?\"\n ]\n , prod = \\_ -> Just $ ordinal 22\n }\n\nruleSeventhOrdinal :: Rule\nruleSeventhOrdinal = Rule\n { name = \"seventh ordinal\"\n , pattern =\n [ regex \"si(o|\u00c3\u00b3)dm(y|ego|emu|m|(a|\u00c4\u2026)|ej)\"\n ]\n , prod = \\_ -> Just $ ordinal 7\n }\n\nruleStOrdinalNoSpace :: Rule\nruleStOrdinalNoSpace = Rule\n { name = \"21st ordinal no space\"\n , pattern =\n [ regex \"dwudziest(ym|y|ego|emu|(a|\u00c4\u2026)|ej)pierw?sz(y|ego|emu|m|(a|\u00c4\u2026)|ej)\"\n ]\n , prod = \\_ -> Just $ ordinal 21\n }\n\nruleThOrdinal7 :: Rule\nruleThOrdinal7 = Rule\n { name = \"14th ordinal\"\n , pattern =\n [ regex \"czternast(ym|y|ego|emu|(a|\u00c4\u2026)|ej)\"\n ]\n , prod = \\_ -> Just $ ordinal 14\n }\n\nruleThOrdinal2 :: Rule\nruleThOrdinal2 = Rule\n { name = \"9th ordinal\"\n , pattern =\n [ regex \"dziewi(a|\u00c4\u2026)t(ym|y|ego|em|emu|(a|\u00c4\u2026)|ej)\"\n ]\n , prod = \\_ -> Just $ ordinal 9\n }\n\nruleThOrdinal9 :: Rule\nruleThOrdinal9 = Rule\n { name = \"16th ordinal\"\n , pattern =\n [ regex \"szesnast(ym|y|ego|emu|(a|\u00c4\u2026)|ej)\"\n ]\n , prod = \\_ -> Just $ ordinal 16\n }\n\nruleThOrdinal :: Rule\nruleThOrdinal = Rule\n { name = \"8th ordinal\"\n , pattern =\n [ regex \"(o|\u00c3\u00b3|\u00c3\u201c)sm(y|ego|emu|m|(a|\u00c4\u2026)|ej)\"\n ]\n , prod = \\_ -> Just $ ordinal 8\n }\n\nruleThOrdinal14 :: Rule\nruleThOrdinal14 = Rule\n { name = \"21-29th ordinal\"\n , pattern =\n [ regex \"dwudziest(ym|y|ego|emu|(a|\u00c4\u2026)|ej)( |-)?\"\n , dimension Ordinal\n ]\n , prod = \\tokens -> case tokens of\n (_:Token Ordinal OrdinalData{TOrdinal.value = v}:_) ->\n Just . ordinal $ 20 + v\n _ -> Nothing\n }\n\nruleThOrdinal10 :: Rule\nruleThOrdinal10 = Rule\n { name = \"17th ordinal\"\n , pattern =\n [ regex \"siedemnast(ym|y|ego|emu|(a|\u00c4\u2026)|ej)\"\n ]\n , prod = \\_ -> Just $ ordinal 17\n }\n\nruleRdOrdinalNoSpace :: Rule\nruleRdOrdinalNoSpace = Rule\n { name = \"23rd ordinal no space\"\n , pattern =\n [ regex \"dwudziest(ym|y|ego|emu|(a|\u00c4\u2026)|ej)trzeci(ego|ch|emu|m|mi|ej|(a|\u00c4\u2026))?\"\n ]\n , prod = \\_ -> Just $ ordinal 23\n }\n\nruleThOrdinal5 :: Rule\nruleThOrdinal5 = Rule\n { name = \"12th ordinal\"\n , pattern =\n [ regex \"dwunast(ym|y|ego|emu|(a|\u00c4\u2026)|ej)\"\n ]\n , prod = \\_ -> Just $ ordinal 12\n }\n\nruleThOrdinal6 :: Rule\nruleThOrdinal6 = Rule\n { name = \"13th ordinal\"\n , pattern =\n [ regex \"trzynast(ym|y|ego|emu|(a|\u00c4\u2026)|ej)\"\n ]\n , prod = \\_ -> Just $ ordinal 13\n }\n\nruleFirstOrdinal :: Rule\nruleFirstOrdinal = Rule\n { name = \"first ordinal\"\n , pattern =\n [ regex \"pierw?sz(y|ego|emu|m|(a|\u00c4\u2026)|ej)\"\n ]\n , prod = \\_ -> Just $ ordinal 1\n }\n\nruleSixthOrdinal :: Rule\nruleSixthOrdinal = Rule\n { name = \"sixth ordinal\"\n , pattern =\n [ regex \"sz(o|\u00c3\u00b3)st(y|ego|emu|m|(a|\u00c4\u2026)|ej)\"\n ]\n , prod = \\_ -> Just $ ordinal 6\n }\n\nruleFourthOrdinal :: Rule\nruleFourthOrdinal = Rule\n { name = \"fourth ordinal\"\n , pattern =\n [ regex \"czwart(y|ego|emu|ym|(a|\u00c4\u2026)|ej)\"\n ]\n , prod = \\_ -> Just $ ordinal 4\n }\n\nruleThOrdinal15 :: Rule\nruleThOrdinal15 = Rule\n { name = \"30th ordinal\"\n , pattern =\n [ regex \"trzydziest(ym|y|ego|emu|(a|\u00c4\u2026)|ej)\"\n ]\n , prod = \\_ -> Just $ ordinal 30\n }\n\nruleThOrdinal12 :: Rule\nruleThOrdinal12 = Rule\n { name = \"19th ordinal\"\n , pattern =\n [ regex \"dziewi(\u00c4\u2122|e)tnast(ym|y|ego|emu|(a|\u00c4\u2026)|ej)\"\n ]\n , prod = \\_ -> Just $ ordinal 19\n }\n\nruleThirdOrdinal :: Rule\nruleThirdOrdinal = Rule\n { name = \"third ordinal\"\n , pattern =\n [ regex \"trzeci(ego|ch|emu|m|mi|ej|(a|\u00c4\u2026))?\"\n ]\n , prod = \\_ -> Just $ ordinal 3\n }\n\nrules :: [Rule]\nrules =\n [ ruleFifthOrdinal\n , ruleFirstOrdinal\n , ruleFourthOrdinal\n , ruleNdOrdinalNoSpace\n , ruleOrdinalDigits\n , ruleRdOrdinalNoSpace\n , ruleSecondOrdinal\n , ruleSeventhOrdinal\n , ruleSixthOrdinal\n , ruleStOrdinalNoSpace\n , ruleThOrdinal\n , ruleThOrdinal10\n , ruleThOrdinal11\n , ruleThOrdinal12\n , ruleThOrdinal13\n , ruleThOrdinal14\n , ruleThOrdinal15\n , ruleThOrdinal16\n , ruleThOrdinal2\n , ruleThOrdinal3\n , ruleThOrdinal4\n , ruleThOrdinal5\n , ruleThOrdinal6\n , ruleThOrdinal7\n , ruleThOrdinal8\n , ruleThOrdinal9\n , ruleThOrdinalNoSpace\n , ruleThirdOrdinal\n ]\n", "num_lines": 318} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Ordinal.PT.Corpus\n ( corpus\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Locale\nimport Duckling.Ordinal.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale PT Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (OrdinalData 1)\n [ \"primeira\"\n , \"primeiros\"\n ]\n , examples (OrdinalData 2)\n [ \"Segundo\"\n , \"segundas\"\n ]\n , examples (OrdinalData 7)\n [ \"setimo\"\n , \"s\u00c3\u00a9timo\"\n , \"s\u00c3\u00a9timas\"\n ]\n , examples (OrdinalData 10)\n [ \"decimos\"\n , \"d\u00c3\u00a9cimos\"\n , \"decima\"\n , \"d\u00c3\u00a9cima\"\n , \"decimas\"\n , \"d\u00c3\u00a9cimas\"\n ]\n , examples (OrdinalData 11)\n [ \"decimos primeiros\"\n , \"d\u00c3\u00a9cimos primeiros\"\n , \"decimo primeiro\"\n , \"d\u00c3\u00a9cimo primeiro\"\n , \"decimas primeiras\"\n , \"d\u00c3\u00a9cimas primeiras\"\n , \"decima primeira\"\n , \"d\u00c3\u00a9cima primeira\"\n ]\n , examples (OrdinalData 12)\n [ \"decimos segundos\"\n , \"d\u00c3\u00a9cimos segundos\"\n , \"decimo segundo\"\n , \"d\u00c3\u00a9cimo segundo\"\n , \"decimas segundas\"\n , \"d\u00c3\u00a9cimas segundas\"\n , \"decima segunda\"\n , \"d\u00c3\u00a9cima segunda\"\n ]\n , examples (OrdinalData 17)\n [ \"decimos setimos\"\n , \"d\u00c3\u00a9cimos setimos\"\n , \"decimo setimo\"\n , \"d\u00c3\u00a9cimo s\u00c3\u00a9timo\"\n , \"decimas setimas\"\n , \"d\u00c3\u00a9cimas s\u00c3\u00a9timas\"\n , \"decima setima\"\n , \"d\u00c3\u00a9cima setima\"\n ]\n , examples (OrdinalData 58)\n [ \"quinquag\u00c3\u00a9simas oitavas\"\n , \"q\u00c3\u00bcinquagesimo oitavo\"\n , \"quinquag\u00c3\u00a9simo oitavo\"\n ]\n ]\n", "num_lines": 84} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Ordinal.PT.Rules\n ( rules\n ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Ordinal.Helpers\nimport Duckling.Ordinal.Types (OrdinalData (..))\nimport Duckling.Regex.Types (GroupMatch (..))\nimport Duckling.Types\nimport qualified Duckling.Ordinal.Types as TOrdinal\n\nordinalsMap :: HashMap Text Int\nordinalsMap = HashMap.fromList\n [ ( \"primeir\", 1 )\n , ( \"segund\", 2 )\n , ( \"terceir\", 3 )\n , ( \"quart\", 4 )\n , ( \"quint\", 5 )\n , ( \"sext\", 6 )\n , ( \"setim\", 7 )\n , ( \"s\u00c3\u00a9tim\", 7 )\n , ( \"oitav\", 8 )\n , ( \"non\", 9 )\n , ( \"decim\", 10 )\n , ( \"d\u00c3\u00a9cim\", 10 )\n ]\n\nruleOrdinals :: Rule\nruleOrdinals = Rule\n { name = \"ordinals (1..10)\"\n , pattern =\n [ regex \"(primeir|segund|terceir|quart|quint|sext|s[\u00c3\u00a9e]tim|oitav|non|d[\u00c3\u00a9e]cim)[ao]s?\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n ordinal <$> HashMap.lookup (Text.toLower match) ordinalsMap\n _ -> Nothing\n }\n\ncardinalsMap :: HashMap Text Int\ncardinalsMap = HashMap.fromList\n [ ( \"vi\", 20 )\n , ( \"tri\", 30 )\n , ( \"quadra\", 40 )\n , ( \"q\u00c3\u00bcinqua\", 50 )\n , ( \"quinqua\", 50 )\n , ( \"sexa\", 60 )\n , ( \"septua\", 70 )\n , ( \"octo\", 80 )\n , ( \"nona\", 90 )\n ]\n\nruleCardinals :: Rule\nruleCardinals = Rule\n { name = \"cardinals (20 .. 90)\"\n , pattern =\n [ regex \"(vi|tri|quadra|q[\u00c3\u00bcu]inqua|sexa|septua|octo|nona)g[\u00c3\u00a9e]sim[ao]s?\"\n ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n ordinal <$> HashMap.lookup (Text.toLower match) cardinalsMap\n _ -> Nothing\n }\n\nruleCompositeOrdinals :: Rule\nruleCompositeOrdinals = Rule\n { name = \"ordinals (11..19)\"\n , pattern =\n [ oneOf [10, 20 .. 90]\n , oneOf [1..9]\n ]\n , prod = \\case\n (Token Ordinal OrdinalData{TOrdinal.value = t}:\n Token Ordinal OrdinalData{TOrdinal.value = u}:\n _) -> Just $ ordinal $ t + u\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleOrdinals\n , ruleCardinals\n , ruleCompositeOrdinals\n ]\n", "num_lines": 103} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Ordinal.RO.Corpus\n ( corpus ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Locale\nimport Duckling.Ordinal.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale RO Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (OrdinalData 1)\n [ \"primul\"\n , \"prima\"\n ]\n , examples (OrdinalData 2)\n [ \"al doilea\"\n , \"al doi-lea\"\n , \"al doi lea\"\n , \"al 2-lea\"\n , \"al 2 lea\"\n , \"a 2 a\"\n , \"a 2-a\"\n , \"a doua\"\n ]\n , examples (OrdinalData 3)\n [ \"al treilea\"\n , \"al trei-lea\"\n , \"a treia\"\n , \"a 3-lea\"\n , \"a 3a\"\n ]\n , examples (OrdinalData 4)\n [ \"a patra\"\n , \"a patru-lea\"\n ]\n , examples (OrdinalData 6)\n [ \"al saselea\"\n , \"al \u00c8\u2122aselea\"\n , \"al sase-lea\"\n , \"al \u00c8\u2122ase-lea\"\n , \"a sasea\"\n , \"a \u00c8\u2122ase a\"\n ]\n , examples (OrdinalData 9)\n [ \"al noualea\"\n , \"al noua-lea\"\n , \"al noua lea\"\n , \"al nou\u00c4\u0192lea\"\n , \"al nou\u00c4\u0192 lea\"\n , \"a noua\"\n ]\n ]\n", "num_lines": 68} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Ordinal.RO.Rules\n ( rules ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport qualified Data.HashMap.Strict as HashMap\nimport Data.Maybe\nimport Data.Text (Text)\nimport qualified Data.Text as Text\nimport Prelude\nimport Data.String\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers (parseInt)\nimport Duckling.Ordinal.Helpers\nimport Duckling.Regex.Types\nimport Duckling.Types\n\nrulePrimulDouaPatraNoua :: Rule\nrulePrimulDouaPatraNoua = Rule\n { name = \"special ordinals\"\n , pattern =\n [ regex \"(prim(a|ul)|a (patra|[dn]oua))\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of\n \"prima\" -> Just $ ordinal 1\n \"primul\" -> Just $ ordinal 1\n \"a doua\" -> Just $ ordinal 2\n \"a patra\" -> Just $ ordinal 4\n \"a noua\" -> Just $ ordinal 9\n _ -> Nothing\n _ -> Nothing\n }\n\n-- We can't have a generic rule of the form \"al?\" + Numeral + \"(le)?a\"\n-- It wouldn't match \"al optlea\"\n\nruleOrdinalDigits :: Rule\nruleOrdinalDigits = Rule\n { name = \"ordinals (digits)\"\n , pattern =\n [ regex \"al?\\\\s0*(\\\\d+)[ -]?(le)?a\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n ordinal <$> parseInt match\n _ -> Nothing\n }\n\nordinalMap :: HashMap Text Int\nordinalMap = HashMap.fromList\n [ (\"doi\", 2)\n , (\"trei\", 3)\n , (\"patru\", 4)\n , (\"cinci\", 5)\n , (\"sase\", 6)\n , (\"\\537ase\", 6)\n , (\"sapte\", 7)\n , (\"\\537apte\", 7)\n , (\"opt\", 8)\n , (\"noua\", 9)\n , (\"nou\u00c4\u0192\", 9)\n ]\n\nruleSpelledOutOrdinals :: Rule\nruleSpelledOutOrdinals = Rule\n { name = \"spelled out ordinals\"\n , pattern =\n [ regex \"al?\\\\s(doi|trei|patru|cinci|(s|\u00c8\u2122)a(s|pt)e|opt|nou(a|\u00c4\u0192))[ -]?(le)?a\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n ordinal <$> HashMap.lookup (Text.toLower match) ordinalMap\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleOrdinalDigits\n , rulePrimulDouaPatraNoua\n , ruleSpelledOutOrdinals\n ]\n", "num_lines": 93} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Ordinal.SV.Corpus\n ( corpus ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Locale\nimport Duckling.Ordinal.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale SV Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (OrdinalData 1)\n [ \"f\u00c3\u00b6rsta\"\n , \"f\u00c3\u00b6rste\"\n , \"1a\"\n , \"1:a\"\n ]\n , examples (OrdinalData 2)\n [ \"andra\"\n , \"andre\"\n , \"2a\"\n , \"2:a\"\n ]\n , examples (OrdinalData 3)\n [ \"tredje\"\n , \"3e\"\n , \"3:e\"\n ]\n , examples (OrdinalData 4)\n [ \"fj\u00c3\u00a4rde\"\n , \"4e\"\n , \"4:e\"\n ]\n , examples (OrdinalData 8)\n [ \"\u00c3\u00a5ttonde\"\n , \"8e\"\n , \"8:e\"\n ]\n , examples (OrdinalData 25)\n [ \"tjugofemte\"\n , \"25e\"\n , \"25:e\"\n ]\n , examples (OrdinalData 31)\n [ \"trettiof\u00c3\u00b6rsta\"\n , \"trettiof\u00c3\u00b6rste\"\n , \"31a\"\n , \"31:a\"\n ]\n , examples (OrdinalData 42)\n [ \"fyrtioandra\"\n , \"fyrtioandre\"\n , \"42a\"\n , \"42:a\"\n ]\n , examples (OrdinalData 77)\n [ \"sjuttiosjunde\"\n , \"77e\"\n , \"77:e\"\n ]\n , examples (OrdinalData 90)\n [ \"nittionde\"\n , \"90e\"\n , \"90:e\"\n ]\n ]\n", "num_lines": 81} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Ordinal.SV.Rules\n ( rules ) where\n\nimport Control.Monad (join)\nimport Data.HashMap.Strict ( HashMap)\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers (parseInt)\nimport Duckling.Ordinal.Helpers\nimport Duckling.Regex.Types\nimport Duckling.Types\n\nordinalsMap :: HashMap Text Int\nordinalsMap = HashMap.fromList\n [ ( \"f\u00c3\u00b6rsta\", 1 )\n , ( \"f\u00c3\u00b6rste\", 1 )\n , ( \"andra\", 2 )\n , ( \"andre\", 2)\n , ( \"tredje\", 3 )\n , ( \"fj\u00c3\u00a4rde\", 4 )\n , ( \"femte\", 5 )\n , ( \"sj\u00c3\u00a4tte\", 6 )\n , ( \"sjunde\", 7 )\n , ( \"\u00c3\u00a5ttonde\", 8 )\n , ( \"nionde\", 9 )\n , ( \"tionde\", 10 )\n , ( \"elfte\", 11 )\n , ( \"tolfte\", 12 )\n , ( \"trettonde\", 13 )\n , ( \"fjortonde\", 14 )\n , ( \"femtonde\", 15 )\n , ( \"sextonde\", 16 )\n , ( \"sjuttonde\", 17 )\n , ( \"artonde\", 18 )\n , ( \"nittonde\", 19 )\n , ( \"tjugonde\", 20 )\n , ( \"trettionde\", 30 )\n , ( \"fyrtionde\", 40 )\n , ( \"femtionde\", 50 )\n , ( \"sextionde\", 60 )\n , ( \"sjuttionde\", 70 )\n , ( \"\u00c3\u00a5ttionde\", 80 )\n , ( \"nittionde\", 90 )\n ]\n\ncardinalsMap :: HashMap Text Int\ncardinalsMap = HashMap.fromList\n [ ( \"tjugo\", 20 )\n , ( \"trettio\", 30 )\n , ( \"fyrtio\", 40 )\n , ( \"femtio\", 50 )\n , ( \"sextio\", 60 )\n , ( \"sjuttio\", 70 )\n , ( \"\u00c3\u00a5ttio\", 80 )\n , ( \"nittio\", 90 )\n ]\n\nruleOrdinals :: Rule\nruleOrdinals = Rule\n { name = \"ordinals (first..twentieth,thirtieth,...)\"\n , pattern =\n [ regex \"(f\u00c3\u00b6rsta|f\u00c3\u00b6rste|andra|andre|tredje|fj\u00c3\u00a4rde|femte|sj\u00c3\u00a4tte|sjunde|\u00c3\u00a5ttonde|nionde|tionde|elfte|tolfte|trettionde|fjortonde|femtonde|sextonde|sjuttonde|artonde|nittonde|tjugonde|trettionde|fyrtionde|femtonde|sextionde|sjuttionde|\u00c3\u00a5ttionde|nittionde)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n ordinal <$> HashMap.lookup (Text.toLower match) ordinalsMap\n _ -> Nothing\n }\n\nruleCompositeOrdinals :: Rule\nruleCompositeOrdinals = Rule\n { name = \"ordinals (composite, e.g., eighty-seven)\"\n , pattern =\n [ regex \"(tjugo|trettio|fyrtio|femtio|sextio|sjuttio|\u00c3\u00a5ttio|nittio)(f\u00c3\u00b6rsta|f\u00c3\u00b6rste|andra|andre|tredje|fj\u00c3\u00a4rde|femte|sj\u00c3\u00a4tte|sjunde|\u00c3\u00a5ttonde|nionde)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (tens:units:_)):_) -> do\n tt <- HashMap.lookup (Text.toLower tens) cardinalsMap\n uu <- HashMap.lookup (Text.toLower units) ordinalsMap\n Just . ordinal $ tt + uu\n _ -> Nothing\n }\n\nruleOrdinalDigits :: Rule\nruleOrdinalDigits = Rule\n { name = \"ordinal (digits)\"\n , pattern =\n [ regex \"0*(\\\\d+):?(a|e)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) -> ordinal <$> parseInt match\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleOrdinals\n , ruleCompositeOrdinals\n , ruleOrdinalDigits\n ]\n", "num_lines": 116} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Ordinal.TR.Corpus\n ( corpus ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Locale\nimport Duckling.Ordinal.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale TR Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (OrdinalData 4)\n [ \"4\u00c3\u00bcnc\u00c3\u00bc\"\n , \"d\u00c3\u00b6rd\u00c3\u00bcnc\u00c3\u00bc\"\n , \"4.\"\n , \"4'\u00c3\u00bcnc\u00c3\u00bc\"\n ]\n , examples (OrdinalData 8)\n [ \"sekizinci\"\n ]\n , examples (OrdinalData 23)\n [ \"yirmi \u00c3\u00bc\u00c3\u00a7\u00c3\u00bcnc\u00c3\u00bc\"\n ]\n ]\n", "num_lines": 39} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Ordinal.TR.Rules\n ( rules ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport qualified Data.HashMap.Strict as HashMap\nimport Data.Text (Text)\nimport qualified Data.Text as Text\nimport Prelude\nimport Data.String\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers (parseInt)\nimport Duckling.Ordinal.Helpers\nimport Duckling.Regex.Types\nimport Duckling.Types\n\nordinals :: [Text]\nordinals =\n [ \"birinci\"\n , \"ikinci\"\n , \"\u00c3\u00bc\u00c3\u00a7\u00c3\u00bcnc\u00c3\u00bc\"\n , \"d\u00c3\u00b6rd\u00c3\u00bcnc\u00c3\u00bc\"\n , \"be\u00c5\u0178inci\"\n , \"alt\u00c4\u00b1nc\u00c4\u00b1\"\n , \"yedinci\"\n , \"sekizinci\"\n , \"dokuzuncu\"\n , \"onuncu\"\n , \"on birinci\"\n , \"on ikinci\"\n , \"on \u00c3\u00bc\u00c3\u00a7\u00c3\u00bcnc\u00c3\u00bc\"\n , \"on d\u00c3\u00b6rd\u00c3\u00bcnc\u00c3\u00bc\"\n , \"on be\u00c5\u0178inci\"\n , \"on alt\u00c4\u00b1nc\u00c4\u00b1\"\n , \"on yedinci\"\n , \"on sekizinci\"\n , \"on dokuzuncu\"\n , \"yirminci\"\n , \"yirmi birinci\"\n , \"yirmi ikinci\"\n , \"yirmi \u00c3\u00bc\u00c3\u00a7\u00c3\u00bcnc\u00c3\u00bc\"\n , \"yirmi d\u00c3\u00b6rd\u00c3\u00bcnc\u00c3\u00bc\"\n , \"yirmi be\u00c5\u0178inci\"\n , \"yirmi alt\u00c4\u00b1nc\u00c4\u00b1\"\n , \"yirmi yedinci\"\n , \"yirmi sekizinci\"\n , \"yirmi dokuzuncu\"\n , \"otuzuncu\"\n , \"otuz birinci\"\n ]\n\nordinalsHashMap :: HashMap Text Int\nordinalsHashMap = HashMap.fromList $ zip ordinals [1..]\n\nruleOrdinalsFirstst :: Rule\nruleOrdinalsFirstst = Rule\n { name = \"ordinals (first..31st)\"\n , pattern =\n [ regex . Text.unpack $\n Text.concat [ \"(\", Text.intercalate \"|\" ordinals, \")\" ]\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n ordinal <$> HashMap.lookup (Text.toLower match) ordinalsHashMap\n _ -> Nothing\n }\n\nruleOrdinalDigits :: Rule\nruleOrdinalDigits = Rule\n { name = \"ordinal (digits)\"\n , pattern =\n [ regex \"0*(\\\\d+) ?('?)(inci|nci|\u00c4\u00b1nc\u00c4\u00b1|nc\u00c4\u00b1|uncu|ncu|\u00c3\u00bcnc\u00c3\u00bc|nc\u00c3\u00bc|.)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):_) ->\n ordinal <$> parseInt match\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleOrdinalDigits\n , ruleOrdinalsFirstst\n ]\n", "num_lines": 95} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Ordinal.VI.Corpus\n ( corpus ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Locale\nimport Duckling.Ordinal.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale VI Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (OrdinalData 1)\n [ \"\u00c4\u2018\u00e1\u00ba\u00a7u ti\u00c3\u00aan\"\n , \"th\u00e1\u00bb\u00a9 nh\u00e1\u00ba\u00a5t\"\n , \"th\u00e1\u00bb\u00a9 1\"\n ]\n ]\n", "num_lines": 31} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Ordinal.VI.Rules\n ( rules ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Dimensions.Types\nimport Duckling.Ordinal.Helpers\nimport Duckling.Types\n\nruleOrdinals :: Rule\nruleOrdinals = Rule\n { name = \"ordinals\"\n , pattern =\n [ regex \"(\u00c4\u2018\u00e1\u00ba\u00a7u ti\u00c3\u00aan|th\u00e1\u00bb\u00a9 nh\u00e1\u00ba\u00a5t|th\u00e1\u00bb\u00a9 1)\"\n ]\n , prod = \\_ -> Just $ ordinal 1\n }\n\nrules :: [Rule]\nrules =\n [ ruleOrdinals\n ]\n", "num_lines": 33} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Ordinal.ZH.Rules\n ( rules ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Types (NumeralData(..))\nimport qualified Duckling.Numeral.Types as TNumeral\nimport Duckling.Ordinal.Helpers\nimport Duckling.Types\n\nruleOrdinalDigits :: Rule\nruleOrdinalDigits = Rule\n { name = \"ordinal (digits)\"\n , pattern =\n [ regex \"\u00e7\u00ac\u00ac\"\n , dimension Numeral\n ]\n , prod = \\tokens -> case tokens of\n (_:Token Numeral NumeralData{TNumeral.value = x}:_) ->\n Just . ordinal $ floor x\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleOrdinalDigits\n ]\n", "num_lines": 40} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.PhoneNumber.Corpus\n ( corpus\n , negativeCorpus\n ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.PhoneNumber.Types\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext, testOptions, allExamples)\n\nnegativeCorpus :: NegativeCorpus\nnegativeCorpus = (testContext, testOptions, examples)\n where\n examples =\n [ \"12345\"\n , \"1234567890123456777777\"\n , \"12345678901234567\"\n ]\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (PhoneNumberValue \"6507018887\")\n [ \"650-701-8887\"\n ]\n , examples (PhoneNumberValue \"(+1) 6507018887\")\n [ \"(+1)650-701-8887\"\n , \"(+1) 650 - 701 8887\"\n , \"(+1) 650-701-8887\"\n , \"+1 6507018887\"\n ]\n , examples (PhoneNumberValue \"(+33) 146647998\")\n [ \"+33 1 46647998\"\n ]\n , examples (PhoneNumberValue \"0620702220\")\n [ \"06 2070 2220\"\n ]\n , examples (PhoneNumberValue \"6507018887 ext 897\")\n [ \"(650)-701-8887 ext 897\"\n ]\n , examples (PhoneNumberValue \"(+1) 2025550121\")\n [ \"+1-202-555-0121\"\n , \"+1 202.555.0121\"\n ]\n , examples (PhoneNumberValue \"4866827\")\n [ \"4.8.6.6.8.2.7\"\n ]\n , examples (PhoneNumberValue \"06354640807\")\n [ \"06354640807\"\n ]\n , examples (PhoneNumberValue \"18998078030\")\n [ \"18998078030\"\n ]\n , examples (PhoneNumberValue \"61992852776\")\n [ \"61 - 9 9285-2776\"\n ]\n , examples (PhoneNumberValue \"19997424919\")\n [ \"(19) 997424919\"\n ]\n , examples (PhoneNumberValue \"(+55) 19992842606\")\n [ \"+55 19992842606\"\n ]\n ]\n", "num_lines": 76} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.PhoneNumber.Rules\n ( rules ) where\n\nimport qualified Data.Text as Text\nimport Prelude\nimport Data.String\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers (parseInt)\nimport Duckling.PhoneNumber.Types (PhoneNumberData(..))\nimport qualified Duckling.PhoneNumber.Types as TPhoneNumber\nimport Duckling.Regex.Types\nimport Duckling.Types\n\nrulePhoneNumber :: Rule\nrulePhoneNumber = Rule\n { name = \"phone number\"\n , pattern =\n -- We somewhat arbitrarly use 20 here to limit the length of matches,\n -- otherwise due to backtracking the regexp will take very long time\n -- or run out of stack for some inputs.\n [ regex $\n \"(?:\\\\(?\\\\+(\\\\d{1,2})\\\\)?[\\\\s-\\\\.]*)?\" ++ -- area code\n \"((?=[-\\\\d()\\\\s\\\\.]{6,16}(?:\\\\s*e?xt?\\\\.?\\\\s*(?:\\\\d{1,20}))?(?:[^\\\\d]+|$))(?:[\\\\d(]{1,20}(?:[-)\\\\s\\\\.]*\\\\d{1,20}){0,20}){1,20})\" ++ -- nums\n \"(?:\\\\s*e?xt?\\\\.?\\\\s*(\\\\d{1,20}))?\" -- extension\n ]\n , prod = \\xs -> case xs of\n (Token RegexMatch (GroupMatch (code:nums:ext:_)):_) ->\n let parseNum x = toInteger <$> parseInt x\n mcode = parseNum code\n mext = parseNum ext\n cleanup = Text.filter (not . isWhitespace)\n isWhitespace x = elem x ['.', ' ', '-', '\\t', '(', ')']\n in Just . Token PhoneNumber $ PhoneNumberData\n { TPhoneNumber.prefix = mcode\n , TPhoneNumber.number = cleanup nums\n , TPhoneNumber.extension = mext\n }\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules = [ rulePhoneNumber ]\n", "num_lines": 54} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE DeriveAnyClass #-}\n{-# LANGUAGE NamedFieldPuns #-}\n{-# LANGUAGE DeriveGeneric #-}\n{-# LANGUAGE NoRebindableSyntax #-}\n{-# LANGUAGE OverloadedStrings #-}\n{-# LANGUAGE TypeFamilies #-}\n\nmodule Duckling.PhoneNumber.Types where\n\nimport Control.DeepSeq\nimport Data.Aeson\nimport Data.Hashable\nimport Data.Monoid\nimport Data.Text (Text)\nimport qualified Data.Text as Text\nimport GHC.Generics\nimport qualified TextShow as TS\n\nimport Prelude\n\nimport Duckling.Resolve (Resolve(..))\n\ndata PhoneNumberData = PhoneNumberData\n { prefix :: Maybe Integer\n , number :: Text\n , extension :: Maybe Integer\n }\n deriving (Eq, Generic, Hashable, Ord, Show, NFData)\n\ninstance Resolve PhoneNumberData where\n type ResolvedValue PhoneNumberData = PhoneNumberValue\n resolve _ _ PhoneNumberData {prefix, number, extension} = Just\n (PhoneNumberValue {value = Text.concat [p, number, e]}, False)\n where\n p = case prefix of\n Just p -> \"(+\" <> TS.showt p <> \") \"\n Nothing -> \"\"\n e = case extension of\n Just e -> \" ext \" <> TS.showt e\n Nothing -> \"\"\n\ndata PhoneNumberValue = PhoneNumberValue { value :: Text }\n deriving (Eq, Ord, Show)\n\ninstance ToJSON PhoneNumberValue where\n toJSON (PhoneNumberValue value) = object\n [ \"value\" .= value\n , \"type\" .= (\"value\" :: Text)\n ]\n", "num_lines": 57} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.PhoneNumber.PT.Corpus\n ( corpus\n ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Locale\nimport Duckling.PhoneNumber.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale PT Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (PhoneNumberValue \"6502834757 ext 897\")\n [ \"(650)-283-4757 ramal 897\"\n ]\n ]\n", "num_lines": 31} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.PhoneNumber.PT.Rules\n ( rules ) where\n\nimport Data.String\nimport Prelude\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers (parseInt)\nimport Duckling.PhoneNumber.Types (PhoneNumberData(..))\nimport Duckling.Regex.Types\nimport Duckling.Types\nimport qualified Duckling.PhoneNumber.Types as TPhoneNumber\n\nrulePhoneNumber :: Rule\nrulePhoneNumber = Rule\n { name = \"phone number\"\n , pattern =\n -- We somewhat arbitrarly use 20 here to limit the length of matches,\n -- otherwise due to backtracking the regexp will take very long time\n -- or run out of stack for some inputs.\n [ regex $\n \"(?:\\\\(?\\\\+(\\\\d{1,2})\\\\)?[\\\\s-\\\\.]*)?\" ++ -- area code\n \"((?=[-\\\\d()\\\\s\\\\.]{6,16}(?:\\\\s*ramal\\\\.?\\\\s*(?:\\\\d{1,20}))?(?:[^\\\\d]+|$))(?:[\\\\d(]{1,20}(?:[-)\\\\s\\\\.]*\\\\d{1,20}){0,20}){1,20})\" ++ -- nums\n \"(?:\\\\s*ramal\\\\.?\\\\s*(\\\\d{1,20}))?\" -- extension\n ]\n , prod = \\xs -> case xs of\n (Token RegexMatch (GroupMatch (code:nums:ext:_)):_) ->\n let parseNum x = toInteger <$> parseInt x\n mcode = parseNum code\n mext = parseNum ext\n cleanup = Text.filter (not . isWhitespace)\n isWhitespace x = elem x ['.', ' ', '-', '\\t', '(', ')']\n in Just . Token PhoneNumber $ PhoneNumberData\n { TPhoneNumber.prefix = mcode\n , TPhoneNumber.number = cleanup nums\n , TPhoneNumber.extension = mext\n }\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ rulePhoneNumber\n ]\n", "num_lines": 56} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n{-# LANGUAGE GADTs #-}\n\n\nmodule Duckling.Quantity.Helpers\n ( getValue\n , isSimpleQuantity\n , quantity\n , unitOnly\n , valueOnly\n , withProduct\n , withUnit\n , withValue\n , withInterval\n , withMin\n , withMax\n , mkLatent\n ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport Data.Text (Text)\nimport Prelude\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Quantity.Types (QuantityData(..))\nimport Duckling.Types\nimport qualified Duckling.Quantity.Types as TQuantity\n\ngetValue :: HashMap Text (Double -> Double) -> Text -> Double -> Double\ngetValue opsMap match = HashMap.lookupDefault id (Text.toLower match) opsMap\n\n-- -----------------------------------------------------------------\n-- Patterns\n\nisSimpleQuantity :: Predicate\nisSimpleQuantity (Token Quantity QuantityData {TQuantity.unit = Just _\n , TQuantity.value = Just _})\n = True\nisSimpleQuantity _ = False\n\n-- -----------------------------------------------------------------\n-- Production\n\nquantity :: TQuantity.Unit -> Double -> QuantityData\nquantity u v = QuantityData {TQuantity.unit = Just u\n , TQuantity.value = Just v\n , TQuantity.aproduct = Nothing\n , TQuantity.minValue = Nothing\n , TQuantity.maxValue = Nothing\n , TQuantity.latent = False}\n\nunitOnly :: TQuantity.Unit -> QuantityData\nunitOnly u = QuantityData {TQuantity.unit = Just u\n , TQuantity.value = Nothing\n , TQuantity.aproduct = Nothing\n , TQuantity.minValue = Nothing\n , TQuantity.maxValue = Nothing\n , TQuantity.latent = False}\n\nvalueOnly :: Double -> QuantityData\nvalueOnly v = QuantityData {TQuantity.unit = Nothing\n , TQuantity.value = Just v\n , TQuantity.aproduct = Nothing\n , TQuantity.minValue = Nothing\n , TQuantity.maxValue = Nothing\n , TQuantity.latent = False}\n\nwithProduct :: Text -> QuantityData -> QuantityData\nwithProduct p qd = qd {TQuantity.aproduct = Just p}\n\nwithUnit :: TQuantity.Unit -> QuantityData -> QuantityData\nwithUnit u qd = qd {TQuantity.unit = Just u}\n\nwithValue :: Double -> QuantityData -> QuantityData\nwithValue value qd = qd {TQuantity.value = Just value}\n\nwithInterval :: (Double, Double) -> QuantityData -> QuantityData\nwithInterval (from, to) qd = qd {minValue = Just from, maxValue = Just to}\n\nwithMin :: Double -> QuantityData -> QuantityData\nwithMin from qd = qd {minValue = Just from}\n\nwithMax :: Double -> QuantityData -> QuantityData\nwithMax to qd = qd {maxValue = Just to}\n\nmkLatent :: QuantityData -> QuantityData\nmkLatent qd = qd {TQuantity.latent = True}\n", "num_lines": 95} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE DeriveAnyClass #-}\n{-# LANGUAGE DeriveGeneric #-}\n{-# LANGUAGE NoRebindableSyntax #-}\n{-# LANGUAGE OverloadedStrings #-}\n{-# LANGUAGE TypeFamilies #-}\nmodule Duckling.Quantity.Types where\n\nimport Control.DeepSeq\nimport Data.Aeson\nimport qualified Data.HashMap.Strict as H\nimport Data.Hashable\nimport Data.Text (Text)\nimport qualified Data.Text as Text\nimport Duckling.Resolve\n ( Resolve(..)\n , Options(..)\n )\nimport GHC.Generics\nimport Prelude\n\ndata Unit\n = Bowl\n | Cup\n | Custom Text\n | Dish\n | Gram\n | Ounce\n | Pint\n | Pound\n | Quart\n | Tablespoon\n | Teaspoon\n | Unnamed\n deriving (Eq, Generic, Hashable, Ord, Show, NFData)\n\ninstance ToJSON Unit where\n toJSON (Custom x) = String $ Text.toLower x\n toJSON x = String . Text.toLower . Text.pack $ show x\n\ndata QuantityData = QuantityData\n { unit :: Maybe Unit\n , value :: Maybe Double\n , aproduct :: Maybe Text\n , minValue :: Maybe Double\n , maxValue :: Maybe Double\n , latent :: Bool\n } deriving (Eq, Generic, Hashable, Ord, Show, NFData)\n\ninstance Resolve QuantityData where\n type ResolvedValue QuantityData = QuantityValue\n resolve _ Options {withLatent = False} QuantityData {latent = True}\n = Nothing\n\n resolve _ _ QuantityData {value = Just value\n , unit = Nothing\n , aproduct = aproduct\n , latent = latent}\n = Just (simple Unnamed value aproduct, latent)\n\n resolve _ _ QuantityData {value = Just value\n , unit = Just unit\n , aproduct = aproduct\n , latent = latent}\n = Just (simple unit value aproduct, latent)\n\n resolve _ _ QuantityData {value = Nothing\n , unit = Just unit\n , aproduct = aproduct\n , minValue = Just from\n , maxValue = Just to\n , latent = latent}\n = Just (between unit (from, to) aproduct, latent)\n\n resolve _ _ QuantityData {value = Nothing\n , unit = Just unit\n , aproduct = aproduct\n , minValue = Just from\n , maxValue = Nothing\n , latent = latent}\n = Just (above unit from aproduct, latent)\n\n resolve _ _ QuantityData {value = Nothing\n , unit = Just unit\n , aproduct = aproduct\n , minValue = Nothing\n , maxValue = Just to\n , latent = latent}\n = Just (under unit to aproduct, latent)\n\n resolve _ _ _ = Nothing\n\ndata IntervalDirection = Above | Under\n deriving (Eq, Generic, Hashable, Ord, Show, NFData)\n\ndata SingleValue =\n SingleValue { vUnit :: Unit, vValue :: Double, vProduct :: Maybe Text }\n deriving (Eq, Generic, Hashable, Ord, Show, NFData)\n\ninstance ToJSON SingleValue where\n toJSON (SingleValue unit value aproduct) = object $\n [ \"value\" .= value\n , \"unit\" .= unit\n ]\n ++ [ \"product\" .= p | Just p <- [aproduct] ]\n\ndata QuantityValue\n = SimpleValue SingleValue\n | IntervalValue (SingleValue, SingleValue)\n | OpenIntervalValue (SingleValue, IntervalDirection)\n deriving (Eq, Ord, Show)\n\ninstance ToJSON QuantityValue where\n toJSON (SimpleValue value) = case toJSON value of\n Object o -> Object $ H.insert \"type\" (toJSON (\"value\" :: Text)) o\n _ -> Object H.empty\n toJSON (IntervalValue (from, to)) = object\n [ \"type\" .= (\"interval\" :: Text)\n , \"from\" .= toJSON from\n , \"to\" .= toJSON to\n ]\n toJSON (OpenIntervalValue (from, Above)) = object\n [ \"type\" .= (\"interval\" :: Text)\n , \"from\" .= toJSON from\n ]\n toJSON (OpenIntervalValue (to, Under)) = object\n [ \"type\" .= (\"interval\" :: Text)\n , \"to\" .= toJSON to\n ]\n\n-- -----------------------------------------------------------------\n-- Value helpers\n\nsimple :: Unit -> Double -> Maybe Text -> QuantityValue\nsimple u v p = SimpleValue $ single u v p\n\nbetween :: Unit -> (Double, Double) -> Maybe Text -> QuantityValue\nbetween u (from, to) p = IntervalValue (single u from p, single u to p)\n\nabove :: Unit -> Double -> Maybe Text -> QuantityValue\nabove = openInterval Above\n\nunder :: Unit -> Double -> Maybe Text -> QuantityValue\nunder = openInterval Under\n\nopenInterval\n :: IntervalDirection -> Unit -> Double -> Maybe Text -> QuantityValue\nopenInterval direction u v p = OpenIntervalValue (single u v p, direction)\n\nsingle :: Unit -> Double -> Maybe Text -> SingleValue\nsingle u v p = SingleValue {vUnit = u, vValue = v, vProduct = p}\n", "num_lines": 158} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Quantity.AR.Rules\n ( rules\n ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers\nimport Duckling.Quantity.Helpers\nimport Duckling.Regex.Types\nimport Duckling.Types\nimport qualified Duckling.Numeral.Types as TNumeral\nimport qualified Duckling.Quantity.Types as TQuantity\n\nquantities :: [(Text, String, TQuantity.Unit)]\nquantities =\n [ (\" cups\", \"(\u00d9\u0192\u00d9\u02c6\u00d8\u00a8(\u00d8\u00a7\u00d9\u2020|\u00d9\u0160\u00d9\u2020)?|[\u00d8\u00a3\u00d8\u00a7]\u00d9\u0192\u00d9\u02c6\u00d8\u00a7\u00d8\u00a8)\", TQuantity.Cup)\n , (\" grams\", \"(((\u00d9\u0192\u00d9\u0160\u00d9\u201e\u00d9\u02c6|\u00d9\u2026\u00d9\u0160?\u00d9\u201e\u00d9\u0160?) ?)?((\u00d8\u00ba|\u00d8\u00ac)\u00d8\u00b1\u00d8\u00a7\u00d9\u2026(\u00d8\u00a7\u00d8\u00aa|\u00d9\u0160\u00d9\u2020|\u00d8\u00a7\u00d9\u2020)?)|\u00d9\u0192(\u00d8\u00ba|\u00d8\u00ac)\u00d9\u2026?|\u00d9\u2026\u00d9\u201e(\u00d8\u00ba|\u00d8\u00ac)|(\u00d8\u00ba|\u00d8\u00ac)\u00d9\u2026)\", TQuantity.Gram)\n , (\" lb\", \"(\u00d8\u00a8\u00d8\u00a7\u00d9\u02c6\u00d9\u2020\u00d8\u00af(\u00d8\u00a7\u00d9\u2020|\u00d9\u0160\u00d9\u2020)?)\", TQuantity.Pound)\n , (\" oz\", \"([\u00d8\u00a3\u00d8\u00a7]\u00d9\u02c6\u00d9\u2020\u00d8\u00b5([\u00d8\u00a9\u00d9\u2021]|\u00d8\u00aa\u00d8\u00a7\u00d9\u2020|\u00d8\u00aa\u00d9\u0160\u00d9\u2020|\u00d8\u00a7\u00d8\u00aa))\", TQuantity.Ounce)\n ]\n\nopsMap :: HashMap Text (Double -> Double)\nopsMap = HashMap.fromList\n [ ( \"\u00d8\u00ba\u00d8\u00b1\u00d8\u00a7\u00d9\u2026\u00d8\u00a7\u00d9\u2020\", (* 2))\n , ( \"\u00d8\u00ba\u00d8\u00b1\u00d8\u00a7\u00d9\u2026\u00d9\u0160\u00d9\u2020\", (* 2))\n , ( \"\u00d9\u0192\u00d9\u02c6\u00d8\u00a8\u00d8\u00a7\u00d9\u2020\", (* 2))\n , ( \"\u00d9\u0192\u00d9\u02c6\u00d8\u00a8\u00d9\u0160\u00d9\u2020\", (* 2))\n , ( \"\u00d8\u00a8\u00d8\u00a7\u00d9\u02c6\u00d9\u2020\u00d8\u00af\u00d8\u00a7\u00d9\u2020\", (* 2))\n , ( \"\u00d8\u00a8\u00d8\u00a7\u00d9\u02c6\u00d9\u2020\u00d8\u00af\u00d9\u0160\u00d9\u2020\", (* 2))\n , ( \"\u00d8\u00a7\u00d9\u02c6\u00d9\u2020\u00d8\u00b5\u00d8\u00aa\u00d8\u00a7\u00d9\u2020\", (* 2))\n , ( \"\u00d8\u00a7\u00d9\u02c6\u00d9\u2020\u00d8\u00b5\u00d8\u00aa\u00d9\u0160\u00d9\u2020\", (* 2))\n , ( \"\u00d8\u00a3\u00d9\u02c6\u00d9\u2020\u00d8\u00b5\u00d8\u00aa\u00d8\u00a7\u00d9\u2020\", (* 2))\n , ( \"\u00d8\u00a3\u00d9\u02c6\u00d9\u2020\u00d8\u00b5\u00d8\u00aa\u00d9\u0160\u00d9\u2020\", (* 2))\n , ( \"\u00d8\u00ac\u00d8\u00b1\u00d8\u00a7\u00d9\u2026\u00d8\u00a7\u00d9\u2020\", (* 2))\n , ( \"\u00d8\u00ac\u00d8\u00b1\u00d8\u00a7\u00d9\u2026\u00d9\u0160\u00d9\u2020\", (* 2))\n , ( \"\u00d9\u2026\u00d9\u0160\u00d9\u201e\u00d9\u0160 \u00d8\u00ba\u00d8\u00b1\u00d8\u00a7\u00d9\u2026\u00d8\u00a7\u00d9\u2020\", (/ 500))\n , ( \"\u00d9\u2026\u00d9\u0160\u00d9\u201e\u00d9\u0160\u00d8\u00ba\u00d8\u00b1\u00d8\u00a7\u00d9\u2026\u00d8\u00a7\u00d9\u2020\", (/ 500))\n , ( \"\u00d9\u2026\u00d9\u0160\u00d9\u201e\u00d8\u00ba\u00d8\u00b1\u00d8\u00a7\u00d9\u2026\u00d8\u00a7\u00d9\u2020\", (/ 500))\n , ( \"\u00d9\u2026\u00d9\u0160\u00d9\u201e\u00d9\u0160 \u00d8\u00ba\u00d8\u00b1\u00d8\u00a7\u00d9\u2026\u00d9\u0160\u00d9\u2020\", (/ 500))\n , ( \"\u00d9\u2026\u00d9\u0160\u00d9\u201e\u00d9\u0160\u00d8\u00ba\u00d8\u00b1\u00d8\u00a7\u00d9\u2026\u00d9\u0160\u00d9\u2020\", (/ 500))\n , ( \"\u00d9\u2026\u00d9\u0160\u00d9\u201e\u00d8\u00ba\u00d8\u00b1\u00d8\u00a7\u00d9\u2026\u00d9\u0160\u00d9\u2020\", (/ 500))\n , ( \"\u00d9\u2026\u00d9\u0160\u00d9\u201e\u00d9\u0160 \u00d8\u00ac\u00d8\u00b1\u00d8\u00a7\u00d9\u2026\u00d8\u00a7\u00d9\u2020\", (/ 500))\n , ( \"\u00d9\u2026\u00d9\u0160\u00d9\u201e\u00d9\u0160\u00d8\u00ac\u00d8\u00b1\u00d8\u00a7\u00d9\u2026\u00d8\u00a7\u00d9\u2020\", (/ 500))\n , ( \"\u00d9\u2026\u00d9\u0160\u00d9\u201e\u00d8\u00ac\u00d8\u00b1\u00d8\u00a7\u00d9\u2026\u00d8\u00a7\u00d9\u2020\", (/ 500))\n , ( \"\u00d9\u2026\u00d9\u0160\u00d9\u201e\u00d9\u0160 \u00d8\u00ac\u00d8\u00b1\u00d8\u00a7\u00d9\u2026\u00d9\u0160\u00d9\u2020\", (/ 500))\n , ( \"\u00d9\u2026\u00d9\u0160\u00d9\u201e\u00d9\u0160\u00d8\u00ac\u00d8\u00b1\u00d8\u00a7\u00d9\u2026\u00d9\u0160\u00d9\u2020\", (/ 500))\n , ( \"\u00d9\u2026\u00d9\u0160\u00d9\u201e\u00d8\u00ac\u00d8\u00b1\u00d8\u00a7\u00d9\u2026\u00d9\u0160\u00d9\u2020\", (/ 500))\n , ( \"\u00d9\u2026\u00d9\u0160\u00d9\u201e\u00d9\u0160 \u00d8\u00ba\u00d8\u00b1\u00d8\u00a7\u00d9\u2026\", (/ 1000))\n , ( \"\u00d9\u2026\u00d9\u0160\u00d9\u201e\u00d9\u0160\u00d8\u00ba\u00d8\u00b1\u00d8\u00a7\u00d9\u2026\", (/ 1000))\n , ( \"\u00d9\u2026\u00d9\u0160\u00d9\u201e\u00d8\u00ba\u00d8\u00b1\u00d8\u00a7\u00d9\u2026\", (/ 1000))\n , ( \"\u00d9\u0192\u00d9\u0160\u00d9\u201e\u00d9\u02c6\u00d8\u00ba\u00d8\u00b1\u00d8\u00a7\u00d9\u2026\", (* 1000))\n , ( \"\u00d9\u0192\u00d9\u0160\u00d9\u201e\u00d9\u02c6 \u00d8\u00ba\u00d8\u00b1\u00d8\u00a7\u00d9\u2026\", (* 1000))\n , ( \"\u00d9\u2026\u00d9\u0160\u00d9\u201e\u00d9\u0160 \u00d8\u00ba\u00d8\u00b1\u00d8\u00a7\u00d9\u2026\u00d8\u00a7\u00d8\u00aa\", (/ 1000))\n , ( \"\u00d9\u2026\u00d9\u0160\u00d9\u201e\u00d9\u0160\u00d8\u00ba\u00d8\u00b1\u00d8\u00a7\u00d9\u2026\u00d8\u00a7\u00d8\u00aa\", (/ 1000))\n , ( \"\u00d9\u2026\u00d9\u0160\u00d9\u201e\u00d8\u00ba\u00d8\u00b1\u00d8\u00a7\u00d9\u2026\u00d8\u00a7\u00d8\u00aa\", (/ 1000))\n , ( \"\u00d9\u2026\u00d9\u201e\u00d8\u00ba\", (/ 1000))\n , ( \"\u00d9\u0192\u00d8\u00ba\", (* 1000))\n , ( \"\u00d9\u0192\u00d8\u00ba\u00d9\u2026\", (* 1000))\n , ( \"\u00d9\u2026\u00d9\u0160\u00d9\u201e\u00d9\u0160 \u00d8\u00ac\u00d8\u00b1\u00d8\u00a7\u00d9\u2026\", (/ 1000))\n , ( \"\u00d9\u2026\u00d9\u0160\u00d9\u201e\u00d9\u0160\u00d8\u00ac\u00d8\u00b1\u00d8\u00a7\u00d9\u2026\", (/ 1000))\n , ( \"\u00d9\u2026\u00d9\u0160\u00d9\u201e\u00d8\u00ac\u00d8\u00b1\u00d8\u00a7\u00d9\u2026\", (/ 1000))\n , ( \"\u00d9\u2026\u00d9\u0160\u00d9\u201e\u00d9\u0160 \u00d8\u00ac\u00d8\u00b1\u00d8\u00a7\u00d9\u2026\u00d8\u00a7\u00d8\u00aa\", (/ 1000))\n , ( \"\u00d9\u2026\u00d9\u0160\u00d9\u201e\u00d9\u0160\u00d8\u00ac\u00d8\u00b1\u00d8\u00a7\u00d9\u2026\u00d8\u00a7\u00d8\u00aa\", (/ 1000))\n , ( \"\u00d9\u2026\u00d9\u0160\u00d9\u201e\u00d8\u00ac\u00d8\u00b1\u00d8\u00a7\u00d9\u2026\u00d8\u00a7\u00d8\u00aa\", (/ 1000))\n , ( \"\u00d9\u0192\u00d9\u0160\u00d9\u201e\u00d9\u02c6\u00d8\u00ba\u00d8\u00b1\u00d8\u00a7\u00d9\u2026\u00d8\u00a7\u00d8\u00aa\", (* 1000))\n , ( \"\u00d9\u0192\u00d9\u0160\u00d9\u201e\u00d9\u02c6 \u00d8\u00ba\u00d8\u00b1\u00d8\u00a7\u00d9\u2026\u00d8\u00a7\u00d8\u00aa\", (* 1000))\n , ( \"\u00d9\u2026\u00d9\u201e\u00d8\u00ac\", (/ 1000))\n , ( \"\u00d9\u0192\u00d9\u0160\u00d9\u201e\u00d9\u02c6\u00d8\u00ac\u00d8\u00b1\u00d8\u00a7\u00d9\u2026\", (* 1000))\n , ( \"\u00d9\u0192\u00d9\u0160\u00d9\u201e\u00d9\u02c6 \u00d8\u00ac\u00d8\u00b1\u00d8\u00a7\u00d9\u2026\", (* 1000))\n , ( \"\u00d9\u0192\u00d9\u0160\u00d9\u201e\u00d9\u02c6\u00d8\u00ac\u00d8\u00b1\u00d8\u00a7\u00d9\u2026\u00d8\u00a7\u00d8\u00aa\", (* 1000))\n , ( \"\u00d9\u0192\u00d9\u0160\u00d9\u201e\u00d9\u02c6 \u00d8\u00ac\u00d8\u00b1\u00d8\u00a7\u00d9\u2026\u00d8\u00a7\u00d8\u00aa\", (* 1000))\n , ( \"\u00d9\u0192\u00d8\u00ac\", (* 1000))\n , ( \"\u00d9\u0192\u00d8\u00ac\u00d9\u2026\", (* 1000))\n , ( \"\u00d9\u0192\u00d9\u0160\u00d9\u201e\u00d9\u02c6\u00d8\u00ba\u00d8\u00b1\u00d8\u00a7\u00d9\u2026\u00d8\u00a7\u00d9\u2020\", (* 2000))\n , ( \"\u00d9\u0192\u00d9\u0160\u00d9\u201e\u00d9\u02c6\u00d8\u00ba\u00d8\u00b1\u00d8\u00a7\u00d9\u2026\u00d9\u0160\u00d9\u2020\", (* 2000))\n , ( \"\u00d9\u0192\u00d9\u0160\u00d9\u201e\u00d9\u02c6 \u00d8\u00ba\u00d8\u00b1\u00d8\u00a7\u00d9\u2026\u00d8\u00a7\u00d9\u2020\", (* 2000))\n , ( \"\u00d9\u0192\u00d9\u0160\u00d9\u201e\u00d9\u02c6 \u00d8\u00ba\u00d8\u00b1\u00d8\u00a7\u00d9\u2026\u00d9\u0160\u00d9\u2020\", (* 2000))\n , ( \"\u00d9\u0192\u00d9\u0160\u00d9\u201e\u00d9\u02c6\u00d8\u00ac\u00d8\u00b1\u00d8\u00a7\u00d9\u2026\u00d8\u00a7\u00d9\u2020\", (* 2000))\n , ( \"\u00d9\u0192\u00d9\u0160\u00d9\u201e\u00d9\u02c6\u00d8\u00ac\u00d8\u00b1\u00d8\u00a7\u00d9\u2026\u00d9\u0160\u00d9\u2020\", (* 2000))\n , ( \"\u00d9\u0192\u00d9\u0160\u00d9\u201e\u00d9\u02c6 \u00d8\u00ac\u00d8\u00b1\u00d8\u00a7\u00d9\u2026\u00d8\u00a7\u00d9\u2020\", (* 2000))\n , ( \"\u00d9\u0192\u00d9\u0160\u00d9\u201e\u00d9\u02c6 \u00d8\u00ac\u00d8\u00b1\u00d8\u00a7\u00d9\u2026\u00d9\u0160\u00d9\u2020\", (* 2000))\n ]\n\nruleNumeralQuantities :: [Rule]\nruleNumeralQuantities = map go quantities\n where\n go :: (Text, String, TQuantity.Unit) -> Rule\n go (name, regexPattern, u) = Rule\n { name = name\n , pattern = [ numberWith TNumeral.value (> 0), regex regexPattern ]\n , prod = \\tokens -> case tokens of\n (Token Numeral nd:\n Token RegexMatch (GroupMatch (match:_)):\n _) -> Just . Token Quantity $ quantity u value\n where value = getValue opsMap match $ TNumeral.value nd\n _ -> Nothing\n }\n\nruleAQuantity :: [Rule]\nruleAQuantity = map go quantities\n where\n go :: (Text, String, TQuantity.Unit) -> Rule\n go (name, regexPattern, u) = Rule\n { name = name\n , pattern = [ regex regexPattern ]\n , prod = \\tokens -> case tokens of\n (Token RegexMatch (GroupMatch (match:_)):\n _) -> Just . Token Quantity $ quantity u $ getValue opsMap match 1\n _ -> Nothing\n }\n\nruleQuantityOfProduct :: Rule\nruleQuantityOfProduct = Rule\n { name = \" of product\"\n , pattern =\n [ dimension Quantity\n , regex \"\u00d9\u2026\u00d9\u2020 ([\u00d8\u00a1-\u00d9\u0160]+)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Quantity qd:Token RegexMatch (GroupMatch (product:_)):_) ->\n Just . Token Quantity $ withProduct product qd\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleQuantityOfProduct\n ]\n ++ ruleNumeralQuantities\n ++ ruleAQuantity\n", "num_lines": 147} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Quantity.EN.Corpus\n ( corpus\n , latentCorpus\n ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Quantity.Types\nimport Duckling.Resolve (Options(..))\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext, testOptions, allExamples)\n\n\nlatentCorpus :: Corpus\nlatentCorpus = (testContext, testOptions {withLatent = True}, latentExamples)\n where\n latentExamples = concat\n [\n examples (simple Unnamed 4 Nothing)\n [ \"around 4\"\n , \"four\"\n , \"~ four\"\n ]\n ,\n examples (simple Unnamed 38.5 Nothing)\n [ \"about 38.5\"\n ]\n ]\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple Pound 2 (Just \"meat\"))\n [ \"two pounds of meat\"\n ]\n , examples (simple Gram 2 Nothing)\n [ \"2 grams\"\n , \"0.002 kg\"\n , \"2 g.\"\n , \"2 gs\"\n , \"2/1000 kilograms\"\n , \"2000 milligrams\"\n , \"2,000 milligrams\"\n ]\n , examples (simple Gram 1000 Nothing)\n [ \"a kilogram\"\n , \"a kg\"\n , \"1 k.g.\"\n , \"1 k.gs\"\n , \"1000 gs\"\n ]\n , examples (simple Pound 1 Nothing)\n [ \"a Pound\"\n , \"1 lb\"\n , \"a lb\"\n ]\n , examples (simple Ounce 2 Nothing)\n [ \"2 ounces\"\n , \"2oz\"\n ]\n , examples (simple Cup 3 (Just \"sugar\"))\n [ \"3 Cups of sugar\"\n , \"3 Cups of SugAr\"\n ]\n , examples (simple Cup 0.75 Nothing)\n [ \"3/4 cup\"\n , \"0.75 cup\"\n , \".75 cups\"\n ]\n , examples (simple Gram 500 (Just \"strawberries\"))\n [ \"500 grams of strawberries\"\n , \"500g of strawberries\"\n , \"0.5 kilograms of strawberries\"\n , \"0.5 kg of strawberries\"\n , \"500000mg of strawberries\"\n ]\n , examples (between Gram (100,1000) (Just \"strawberries\"))\n [ \"100-1000 gram of strawberries\"\n , \"between 100 and 1000 grams of strawberries\"\n , \"from 100 to 1000 g of strawberries\"\n , \"100 - 1000 g of strawberries\"\n ]\n , examples (between Gram (2,7) Nothing)\n [ \"around 2 -7 g\"\n , \"~2-7 grams\"\n , \"from 2 to 7 g\"\n , \"between 2.0 g and about 7.0 g\"\n , \"between 0.002 kg and about 0.007 kg\"\n , \"2 - ~7 grams\"\n ]\n , examples (under Pound 6 (Just \"meat\"))\n [ \"less than six pounds of meat\"\n , \"no more than 6 lbs of meat\"\n , \"below 6.0 pounds of meat\"\n , \"at most six pounds of meat\"\n ]\n , examples (above Cup 2 Nothing)\n [ \"exceeding 2 Cups\"\n , \"at least two Cups\"\n , \"over 2 Cups\"\n , \"more than 2 Cups\"\n ]\n , examples (above Ounce 4 (Just \"chocolate\"))\n [ \"exceeding 4 oz of chocolate\"\n , \"at least 4.0 oz of chocolate\"\n , \"over four ounces of chocolate\"\n , \"more than four ounces of chocolate\"\n ]\n ]\n", "num_lines": 121} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n{-# LANGUAGE LambdaCase #-}\n\nmodule Duckling.Quantity.EN.Rules\n ( rules\n ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers\nimport Duckling.Quantity.Helpers\nimport Duckling.Regex.Types (GroupMatch(..))\nimport Duckling.Types\nimport Duckling.Numeral.Types (NumeralData(..))\nimport Duckling.Quantity.Types (QuantityData(..))\nimport qualified Duckling.Numeral.Types as TNumeral\nimport qualified Duckling.Quantity.Types as TQuantity\n\nquantities :: [(Text, String, TQuantity.Unit)]\nquantities =\n [ (\" cups\", \"(cups?)\", TQuantity.Cup)\n , (\" grams\", \"(((m(illi)?[.]?)|(k(ilo)?)[.]?)?g(ram)?s?[.]?)[.]?\", TQuantity.Gram)\n , (\" lb\", \"((lb|pound)s?)\", TQuantity.Pound)\n , (\" oz\", \"((ounces?)|oz)\", TQuantity.Ounce)\n ]\n\nopsMap :: HashMap Text (Double -> Double)\nopsMap = HashMap.fromList\n [ ( \"milligram\" , (/ 1000))\n , ( \"milligrams\", (/ 1000))\n , ( \"mg\" , (/ 1000))\n , ( \"mgs\" , (/ 1000))\n , ( \"m.g\" , (/ 1000))\n , ( \"m.gs\" , (/ 1000))\n , ( \"m.g.\" , (/ 1000))\n , ( \"m.g.s\" , (/ 1000))\n , ( \"kilogram\" , (* 1000))\n , ( \"kilograms\" , (* 1000))\n , ( \"kg\" , (* 1000))\n , ( \"kgs\" , (* 1000))\n , ( \"k.g\" , (* 1000))\n , ( \"k.gs\" , (* 1000))\n , ( \"k.g.\" , (* 1000))\n , ( \"k.g.s\" , (* 1000))\n ]\n\nruleNumeralQuantities :: [Rule]\nruleNumeralQuantities = map go quantities\n where\n go :: (Text, String, TQuantity.Unit) -> Rule\n go (name, regexPattern, u) = Rule\n { name = name\n , pattern = [Predicate isPositive, regex regexPattern]\n , prod = \\case\n (Token Numeral nd:\n Token RegexMatch (GroupMatch (match:_)):\n _) -> Just . Token Quantity $ quantity u value\n where value = getValue opsMap match $ TNumeral.value nd\n _ -> Nothing\n }\n\nruleAQuantity :: [Rule]\nruleAQuantity = map go quantities\n where\n go :: (Text, String, TQuantity.Unit) -> Rule\n go (name, regexPattern, u) = Rule\n { name = name\n , pattern = [ regex (\"an? \" ++ regexPattern) ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):\n _) -> Just . Token Quantity $ quantity u $ getValue opsMap match 1\n _ -> Nothing\n }\n\nruleQuantityOfProduct :: Rule\nruleQuantityOfProduct = Rule\n { name = \" of product\"\n , pattern =\n [ dimension Quantity\n , regex \"of (\\\\w+)\"\n ]\n , prod = \\case\n (Token Quantity qd:Token RegexMatch (GroupMatch (product:_)):_) ->\n Just . Token Quantity $ withProduct (Text.toLower product) qd\n _ -> Nothing\n }\n\nrulePrecision :: Rule\nrulePrecision = Rule\n { name = \"about|exactly \"\n , pattern =\n [ regex \"\\\\~|exactly|precisely|about|approx(\\\\.|imately)?|close to|near( to)?|around|almost\"\n , dimension Quantity\n ]\n , prod = \\case\n (_:token:_) -> Just token\n _ -> Nothing\n }\n\nruleIntervalBetweenNumeral :: Rule\nruleIntervalBetweenNumeral = Rule\n { name = \"between|from and|to \"\n , pattern =\n [ regex \"between|from\"\n , Predicate isPositive\n , regex \"to|and\"\n , Predicate isSimpleQuantity\n ]\n , prod = \\case\n (_:\n Token Numeral NumeralData{TNumeral.value = from}:\n _:\n Token Quantity QuantityData{TQuantity.value = Just to\n , TQuantity.unit = Just u\n , TQuantity.aproduct = Nothing}:\n _) | from < to ->\n Just . Token Quantity . withInterval (from, to) $ unitOnly u\n _ -> Nothing\n }\n\nruleIntervalBetween :: Rule\nruleIntervalBetween = Rule\n { name = \"between|from to|and \"\n , pattern =\n [ regex \"between|from\"\n , Predicate isSimpleQuantity\n , regex \"and|to\"\n , Predicate isSimpleQuantity\n ]\n , prod = \\case\n (_:\n Token Quantity QuantityData{TQuantity.value = Just from\n , TQuantity.unit = Just u1\n , TQuantity.aproduct = Nothing}:\n _:\n Token Quantity QuantityData{TQuantity.value = Just to\n , TQuantity.unit = Just u2\n , TQuantity.aproduct = Nothing}:\n _) | from < to && u1 == u2 ->\n Just . Token Quantity . withInterval (from, to) $ unitOnly u1\n _ -> Nothing\n }\n\nruleIntervalNumeralDash :: Rule\nruleIntervalNumeralDash = Rule\n { name = \" - \"\n , pattern =\n [ Predicate isPositive\n , regex \"\\\\-\"\n , Predicate isSimpleQuantity\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = from}:\n _:\n Token Quantity QuantityData{TQuantity.value = Just to\n , TQuantity.unit = Just u\n , TQuantity.aproduct = Nothing}:\n _) | from < to ->\n Just . Token Quantity . withInterval (from, to) $ unitOnly u\n _ -> Nothing\n }\n\nruleIntervalDash :: Rule\nruleIntervalDash = Rule\n { name = \" - \"\n , pattern =\n [ Predicate isSimpleQuantity\n , regex \"\\\\-\"\n , Predicate isSimpleQuantity\n ]\n , prod = \\case\n (Token Quantity QuantityData{TQuantity.value = Just from\n , TQuantity.unit = Just u1\n , TQuantity.aproduct = Nothing}:\n _:\n Token Quantity QuantityData{TQuantity.value = Just to\n , TQuantity.unit = Just u2\n , TQuantity.aproduct = Nothing}:\n _) | from < to && u1 == u2 ->\n Just . Token Quantity . withInterval (from, to) $ unitOnly u1\n _ -> Nothing\n }\n\nruleIntervalMax :: Rule\nruleIntervalMax = Rule\n { name = \"under/below/less/lower/at most/no more than \"\n , pattern =\n [ regex \"under|below|at most|(less|lower|not? more) than\"\n , Predicate isSimpleQuantity\n ]\n , prod = \\case\n (_:\n Token Quantity QuantityData{TQuantity.value = Just to\n , TQuantity.unit = Just u\n , TQuantity.aproduct = Nothing}:\n _) -> Just . Token Quantity . withMax to $ unitOnly u\n _ -> Nothing\n }\n\nruleIntervalMin :: Rule\nruleIntervalMin = Rule\n { name = \"over/above/exceeding/beyond/at least/more than \"\n , pattern =\n [ regex \"over|above|exceeding|beyond|at least|(more|larger|bigger|heavier) than\"\n , Predicate isSimpleQuantity\n ]\n , prod = \\case\n (_:\n Token Quantity QuantityData{TQuantity.value = Just from\n , TQuantity.unit = Just u\n , TQuantity.aproduct = Nothing}:\n _) -> Just . Token Quantity . withMin from $ unitOnly u\n _ -> Nothing\n }\n\nruleQuantityLatent :: Rule\nruleQuantityLatent = Rule\n { name = \" (latent)\"\n , pattern =\n [ Predicate isPositive\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = v}: _) ->\n Just $ (Token Quantity . mkLatent) $ valueOnly v\n _ -> Nothing\n }\n\n\nrules :: [Rule]\nrules =\n [ ruleQuantityOfProduct\n , ruleIntervalMin\n , ruleIntervalMax\n , ruleIntervalBetweenNumeral\n , ruleIntervalBetween\n , ruleIntervalNumeralDash\n , ruleIntervalDash\n , rulePrecision\n , ruleQuantityLatent\n ]\n ++ ruleNumeralQuantities\n ++ ruleAQuantity\n", "num_lines": 257} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Quantity.ES.Corpus\n ( corpus\n ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Locale\nimport Duckling.Quantity.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncontext :: Context\ncontext = testContext { locale = makeLocale ES Nothing }\n\ncorpus :: Corpus\ncorpus = (context, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple Pound 2 (Just \"carne\"))\n [ \"dos libras de carne\"\n ]\n , examples (simple Gram 2 Nothing)\n [ \"dos gramos\"\n , \"0,002 kg\"\n , \"2/1000 kilogramos\"\n , \"2000 miligramos\"\n ]\n , examples (simple Gram 1000 Nothing)\n [ \"un kilogramo\"\n , \"un kg\"\n ]\n , examples (simple Pound 1 Nothing)\n [ \"una libra\"\n , \"1 lb\"\n , \"una lb\"\n ]\n , examples (simple Ounce 2 Nothing)\n [ \"2 onzas\"\n , \"2oz\"\n ]\n , examples (simple Cup 3 (Just \"azucar\"))\n [ \"tres tazas de azucar\"\n , \"3 tazas de AzUcAr\"\n ]\n , examples (simple Cup 0.75 Nothing)\n [ \"3/4 taza\"\n , \"0,75 taza\"\n , \",75 tazas\"\n ]\n , examples (simple Gram 500 (Just \"fresas\"))\n [ \"500 gramos de fresas\"\n , \"500g de fresas\"\n , \"0,5 kilogramos de fresas\"\n , \"0,5 kg de fresas\"\n , \"500000mg de fresas\"\n ]\n , examples (under Pound 6 (Just \"carne\"))\n [ \"menos que seis libras de carne\"\n , \"no m\u00c3\u00a1s que 6 lbs de carne\"\n , \"por debajo de 6,0 libras de carne\"\n , \"a lo sumo seis libras de carne\"\n ]\n , examples (above Cup 2 Nothing)\n [ \"excesivo 2 tazas\"\n , \"como m\u00c3\u00adnimo dos tazas\"\n , \"mayor de 2 tazas\"\n , \"m\u00c3\u00a1s de 2 tazas\"\n ]\n , examples (above Ounce 4 (Just \"chocolate\"))\n [ \"excesivo 4 oz de chocolate\"\n , \"al menos 4,0 oz de chocolate\"\n , \"mayor de cuatro onzas de chocolate\"\n , \"m\u00c3\u00a1s de cuatro onzas de chocolate\"\n ]\n ]\n", "num_lines": 87} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n{-# LANGUAGE LambdaCase #-}\n\nmodule Duckling.Quantity.ES.Rules\n ( rules\n ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers\nimport Duckling.Quantity.Helpers\nimport Duckling.Regex.Types (GroupMatch(..))\nimport Duckling.Types\nimport Duckling.Numeral.Types (NumeralData(..))\nimport Duckling.Quantity.Types (QuantityData(..))\nimport qualified Duckling.Numeral.Types as TNumeral\nimport qualified Duckling.Quantity.Types as TQuantity\n\n-- Our quantities: (name, regex, quantityType). Please make sure to wrap\n-- each regex in parentheses, because we extend these regexes later with\n-- articles (un/una).\nquantities :: [(Text, String, TQuantity.Unit)]\nquantities =\n [ (\" bowls\", \"(bol(es)?|taz\u00c3\u00b3n(es)?|cuencos?|platos? (soperos?)|(hondos?))\", TQuantity.Bowl)\n , (\" cups\", \"(tazas?)\", TQuantity.Cup)\n , (\" dishes\", \"(platos?|fuentes?)\", TQuantity.Dish)\n , (\" grams\", \"(((m(ili)?)|(k(ilo)?))?g(ramo)?s?)\", TQuantity.Gram)\n , (\" ounces\", \"((onzas?)|oz)\", TQuantity.Ounce)\n , (\" pints\", \"(pintas?)\", TQuantity.Pint)\n , (\" pounds\", \"((lb|libra)s?)\", TQuantity.Pound)\n , (\" quarts\", \"(cuartos? de gal\u00c3\u00b3n)\", TQuantity.Quart)\n , (\" tablespoons\", \"(cucharadas? (grande)?)\", TQuantity.Tablespoon)\n , (\" teaspoons\", \"(cucharaditas?)\", TQuantity.Teaspoon)\n ]\n\nopsMap :: HashMap Text (Double -> Double)\nopsMap = HashMap.fromList\n [ ( \"miligram\" , (/ 1000))\n , ( \"miligramos\" , (/ 1000))\n , ( \"mg\" , (/ 1000))\n , ( \"mgs\" , (/ 1000))\n , ( \"kilogramo\" , (* 1000))\n , ( \"kilogramos\" , (* 1000))\n , ( \"kg\" , (* 1000))\n , ( \"kgs\" , (* 1000))\n ]\n\nruleNumeralQuantities :: [Rule]\nruleNumeralQuantities = map go quantities\n where\n go :: (Text, String, TQuantity.Unit) -> Rule\n go (nm, regexPattern, u) = Rule\n { name = nm\n , pattern = [Predicate isPositive, regex regexPattern]\n , prod = \\case\n (Token Numeral nd:\n Token RegexMatch (GroupMatch (match:_)):\n _) -> Just $ Token Quantity $ quantity u val\n where val = getValue opsMap match $ TNumeral.value nd\n _ -> Nothing\n }\n\n-- Quantities prefixed by \"un\" or \"una\"\nruleAQuantity :: [Rule]\nruleAQuantity = map go quantities\n where\n go :: (Text, String, TQuantity.Unit) -> Rule\n go (nm, regexPattern, u) = Rule\n { name = nm\n , pattern = [ regex (\"una? \" ++ regexPattern) ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):\n _) -> Just $ Token Quantity $ quantity u $ getValue opsMap match 1\n _ -> Nothing\n }\n\nruleQuantityOfProduct :: Rule\nruleQuantityOfProduct = Rule\n { name = \" de producto\"\n , pattern =\n [ dimension Quantity\n , regex \"de (\\\\w+)\"\n ]\n , prod = \\case\n (Token Quantity qd:Token RegexMatch (GroupMatch (prdct:_)):_) ->\n Just $ Token Quantity $ withProduct (Text.toLower prdct) qd\n _ -> Nothing\n }\n\nrulePrecision :: Rule\nrulePrecision = Rule\n { name = \"about|exactly \"\n , pattern =\n [ regex \"exactamente|precisamente|a?cerca( de)?|aproximadamente|casi\"\n , dimension Quantity\n ]\n , prod = \\case\n (_:tkn:_) -> Just tkn\n _ -> Nothing\n }\n\nruleIntervalBetweenNumeral :: Rule\nruleIntervalBetweenNumeral = Rule\n { name = \"between|from and|to \"\n , pattern =\n [ regex \"entre|de\"\n , Predicate isPositive\n , regex \"a|y\"\n , Predicate isSimpleQuantity\n ]\n , prod = \\case\n (_:\n Token Numeral NumeralData{TNumeral.value = from}:\n _:\n Token Quantity QuantityData{TQuantity.value = Just to\n , TQuantity.unit = Just u\n , TQuantity.aproduct = Nothing}:\n _) | from < to ->\n Just $ Token Quantity $ withInterval (from, to) $ unitOnly u\n _ -> Nothing\n }\n\nruleIntervalBetween :: Rule\nruleIntervalBetween = Rule\n { name = \"between|from to|and \"\n , pattern =\n [ regex \"entre/de\"\n , Predicate isSimpleQuantity\n , regex \"a/y\"\n , Predicate isSimpleQuantity\n ]\n , prod = \\case\n (_:\n Token Quantity QuantityData{TQuantity.value = Just from\n , TQuantity.unit = Just u1\n , TQuantity.aproduct = Nothing}:\n _:\n Token Quantity QuantityData{TQuantity.value = Just to\n , TQuantity.unit = Just u2\n , TQuantity.aproduct = Nothing}:\n _) | from < to && u1 == u2 ->\n Just $ Token Quantity $ withInterval (from, to) $ unitOnly u1\n _ -> Nothing\n }\n\nruleIntervalNumeralDash :: Rule\nruleIntervalNumeralDash = Rule\n { name = \" - \"\n , pattern =\n [ Predicate isPositive\n , regex \"\\\\-\"\n , Predicate isSimpleQuantity\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = from}:\n _:\n Token Quantity QuantityData{TQuantity.value = Just to\n , TQuantity.unit = Just u\n , TQuantity.aproduct = Nothing}:\n _) | from < to ->\n Just $ Token Quantity $ withInterval (from, to) $ unitOnly u\n _ -> Nothing\n }\n\nruleIntervalDash :: Rule\nruleIntervalDash = Rule\n { name = \" - \"\n , pattern =\n [ Predicate isSimpleQuantity\n , regex \"\\\\-\"\n , Predicate isSimpleQuantity\n ]\n , prod = \\case\n (Token Quantity QuantityData{TQuantity.value = Just from\n , TQuantity.unit = Just u1\n , TQuantity.aproduct = Nothing}:\n _:\n Token Quantity QuantityData{TQuantity.value = Just to\n , TQuantity.unit = Just u2\n , TQuantity.aproduct = Nothing}:\n _) | from < to && u1 == u2 ->\n Just $ Token Quantity $ withInterval (from, to) $ unitOnly u1\n _ -> Nothing\n }\n\nruleIntervalMax :: Rule\nruleIntervalMax = Rule\n { name = \"under/below/less/lower/at most/no more than \"\n , pattern =\n [ regex \"no m(\u00c3\u00a1|a)s que|menos de|por debajo de|como mucho|como m(\u00c3\u00a1|a)xim(o|a)|a lo sumo|menos (que|de)\"\n , Predicate isSimpleQuantity\n ]\n , prod = \\case\n (_:\n Token Quantity QuantityData{TQuantity.value = Just to\n , TQuantity.unit = Just u\n , TQuantity.aproduct = Nothing}:\n _) -> Just $ Token Quantity $ withMax to $ unitOnly u\n _ -> Nothing\n }\n\nruleIntervalMin :: Rule\nruleIntervalMin = Rule\n { name = \"over/above/exceeding/beyond/at least/more than \"\n , pattern =\n [ regex \"(? Just $ Token Quantity $ withMin from $ unitOnly u\n _ -> Nothing\n }\n\nruleQuantityLatent :: Rule\nruleQuantityLatent = Rule\n { name = \" (latent)\"\n , pattern =\n [ Predicate isPositive\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = v}: _) ->\n Just $ Token Quantity $ mkLatent $ valueOnly v\n _ -> Nothing\n }\n\n\nrules :: [Rule]\nrules =\n [ ruleQuantityOfProduct\n , ruleIntervalMin\n , ruleIntervalMax\n , ruleIntervalBetweenNumeral\n , ruleIntervalBetween\n , ruleIntervalNumeralDash\n , ruleIntervalDash\n , rulePrecision\n , ruleQuantityLatent\n ]\n ++ ruleNumeralQuantities\n ++ ruleAQuantity\n", "num_lines": 259} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Quantity.FR.Corpus\n ( corpus ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Locale\nimport Duckling.Quantity.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale FR Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple Cup 2 (Just \"caf\u00c3\u00a9\"))\n [ \"2 tasses de caf\u00c3\u00a9\"\n ]\n , examples (simple Cup 1 Nothing)\n [ \"une Tasse\"\n ]\n , examples (simple Tablespoon 3 (Just \"sucre\"))\n [ \"3 Cuill\u00c3\u00a8res \u00c3\u00a0 soupe de sucre\"\n ]\n ]\n", "num_lines": 36} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Quantity.FR.Rules\n ( rules\n ) where\n\nimport Data.String\nimport Prelude\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Quantity.Helpers\nimport Duckling.Numeral.Types (NumeralData (..))\nimport Duckling.Regex.Types\nimport Duckling.Types\nimport qualified Duckling.Numeral.Types as TNumeral\nimport qualified Duckling.Quantity.Types as TQuantity\n\nruleNumeralUnits :: Rule\nruleNumeralUnits = Rule\n { name = \" \"\n , pattern =\n [ dimension Numeral\n , regex \"(tasses?|cuill?(e|\u00c3\u00a8)res? (a|\u00c3\u00a0) soupe?)\"\n ]\n , prod = \\case\n (Token Numeral NumeralData {TNumeral.value = v}:\n Token RegexMatch (GroupMatch (match:_)):\n _) -> case Text.toLower match of\n \"tasse\" -> Just . Token Quantity $ quantity TQuantity.Cup v\n \"tasses\" -> Just . Token Quantity $ quantity TQuantity.Cup v\n _ -> Just . Token Quantity $ quantity TQuantity.Tablespoon v\n _ -> Nothing\n }\n\nruleQuantityOfProduct :: Rule\nruleQuantityOfProduct = Rule\n { name = \" of product\"\n , pattern =\n [ dimension Quantity\n , regex \"de (caf(e|\u00c3\u00a9)|sucre)\"\n ]\n , prod = \\case\n (Token Quantity qd:\n Token RegexMatch (GroupMatch (match:_)):\n _) -> Just . Token Quantity $ withProduct match qd\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleNumeralUnits\n , ruleQuantityOfProduct\n ]\n", "num_lines": 64} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Quantity.HR.Corpus\n ( corpus ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Locale\nimport Duckling.Quantity.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale HR Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple Gram 2000 (Just \"meso\"))\n [ \"dvije kile mesa\"\n , \"dva kilograma mesa\"\n ]\n , examples (simple Gram 1000 Nothing)\n [ \"1 kilograma\"\n ]\n ]\n", "num_lines": 33} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Quantity.HR.Rules\n ( rules ) where\n\nimport Data.String\nimport Prelude\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Types (NumeralData (..))\nimport Duckling.Quantity.Helpers\nimport Duckling.Regex.Types\nimport Duckling.Types\nimport qualified Duckling.Numeral.Types as TNumeral\nimport qualified Duckling.Quantity.Types as TQuantity\n\nruleNumberUnits :: Rule\nruleNumberUnits = Rule\n { name = \" \"\n , pattern =\n [ dimension Numeral\n , regex \"k(il(o|e|a))?(g(rama?)?)?\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Numeral NumeralData {TNumeral.value = v}:_) ->\n Just . Token Quantity $ quantity TQuantity.Gram (1000 * v)\n _ -> Nothing\n }\n\nruleQuantityProduct :: Rule\nruleQuantityProduct = Rule\n { name = \" product\"\n , pattern =\n [ dimension Quantity\n , regex \"(mes(o|a)|soli?)\"\n ]\n , prod = \\tokens -> case tokens of\n (Token Quantity qd:\n Token RegexMatch (GroupMatch (match:_)):\n _) -> case Text.toLower match of\n \"meso\" -> Just . Token Quantity $ withProduct \"meso\" qd\n \"mesa\" -> Just . Token Quantity $ withProduct \"meso\" qd\n \"sol\" -> Just . Token Quantity $ withProduct \"sol\" qd\n \"soli\" -> Just . Token Quantity $ withProduct \"sol\" qd\n _ -> Nothing\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleNumberUnits\n , ruleQuantityProduct\n ]\n", "num_lines": 62} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Quantity.MN.Corpus\n ( corpus\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Locale\nimport Duckling.Resolve\nimport Duckling.Quantity.Types\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale MN Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple Pound 2 Nothing)\n [ \"2 \u00d1\u201e\u00d1\u0192\u00d0\u00bd\u00d1\u201a\"\n ]\n , examples (simple Gram 2 Nothing)\n [ \"2 \u00d0\u00b3\u00d1\u20ac\u00d0\u00b0\u00d0\u00bc\u00d0\u00bc\"\n , \"\u00d1\u2026\u00d0\u00be\u00d1\u2018\u00d1\u20ac \u00d0\u00b3\u00d1\u20ac\u00d0\u00b0\u00d0\u00bc\u00d0\u00bc\"\n , \"2000 \u00d0\u00bc\u00d0\u00b8\u00d0\u00bb\u00d0\u00bb\u00d0\u00b8\u00d0\u00b3\u00d1\u20ac\u00d0\u00b0\u00d0\u00bc\u00d0\u00bc\"\n , \"2000 \u00d0\u00bc\u00d0\u00b3\"\n ]\n , examples (simple Gram 1000 Nothing)\n [ \"\u00d0\u00ba\u00d0\u00b8\u00d0\u00bb\u00d0\u00be\u00d0\u00b3\u00d1\u20ac\u00d0\u00b0\u00d0\u00bc\u00d0\u00bc\"\n , \"\u00d0\u00ba\u00d0\u00b3\"\n ]\n , examples (simple Gram 2000 Nothing)\n [ \"2 \u00d0\u00ba\u00d0\u00b8\u00d0\u00bb\u00d0\u00be\u00d0\u00b3\u00d1\u20ac\u00d0\u00b0\u00d0\u00bc\u00d0\u00bc\"\n , \"2 \u00d0\u00ba\u00d0\u00b3\"\n , \"2000 \u00d0\u00b3\u00d1\u20ac\u00d0\u00b0\u00d0\u00bc\u00d0\u00bc\"\n ]\n , examples (simple Pound 1 Nothing)\n [ \"\u00d1\u201e\u00d1\u0192\u00d0\u00bd\u00d1\u201a\"\n , \"1 \u00d1\u201e\u00d1\u0192\u00d0\u00bd\u00d1\u201a\"\n ]\n , examples (simple Ounce 2 Nothing)\n [ \"2 \u00d1\u0192\u00d0\u00bd\u00d1\u2020\"\n ]\n , examples (simple Gram 500 Nothing)\n [ \"500 \u00d0\u00b3\u00d1\u20ac\u00d0\u00b0\u00d0\u00bc\u00d0\u00bc\"\n , \"500\u00d0\u00b3\"\n , \"500 \u00d0\u00b3\"\n , \"0.5 \u00d0\u00ba\u00d0\u00b3\"\n ]\n ]\n", "num_lines": 59} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Quantity.MN.Rules\n ( rules\n ) where\n\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers\nimport Duckling.Quantity.Helpers\nimport Duckling.Regex.Types\nimport Duckling.Types\nimport qualified Duckling.Numeral.Types as TNumeral\nimport qualified Duckling.Quantity.Types as TQuantity\n\nquantities :: [(Text, String, TQuantity.Unit, Double -> Double)]\nquantities =\n [ (\" milligrams\", \"(\u00d0\u00bc\u00d0\u00b3|\u00d0\u00bc\u00d0\u00b8\u00d0\u00bb\u00d0\u00bb\u00d0\u00b8\u00d0\u00b3\u00d1\u20ac\u00d0\u00b0\u00d0\u00bc\u00d0\u00bc)\", TQuantity.Gram, (/ 1000))\n , (\" grams\", \"\u00d0\u00b3(\u00d1\u20ac\u00d0\u00b0\u00d0\u00bc\u00d0\u00bc?)?\", TQuantity.Gram, id)\n , (\" kilograms\", \"(\u00d0\u00ba\u00d0\u00b3|\u00d0\u00ba\u00d0\u00b8\u00d0\u00bb\u00d0\u00be\u00d0\u00b3\u00d1\u20ac\u00d0\u00b0\u00d0\u00bc\u00d0\u00bc?)\", TQuantity.Gram, (* 1000))\n , (\" lb\", \"\u00d1\u201e\u00d1\u0192\u00d0\u00bd\u00d1\u201a\", TQuantity.Pound, id)\n , (\" oz\", \"\u00d1\u0192\u00d0\u00bd\u00d1\u2020\", TQuantity.Ounce, id)\n ]\n\nruleNumeralQuantities :: [Rule]\nruleNumeralQuantities = map go quantities\n where\n go :: (Text, String, TQuantity.Unit, Double -> Double) -> Rule\n go (name, regexPattern, u, convert) = Rule\n { name = name\n , pattern =\n [ numberWith TNumeral.value (> 0), regex regexPattern ]\n , prod = \\tokens -> case tokens of\n (Token Numeral nd:_) ->\n Just . Token Quantity . quantity u . convert $ TNumeral.value nd\n _ -> Nothing\n }\n\nruleAQuantity :: [Rule]\nruleAQuantity = map go quantities\n where\n go :: (Text, String, TQuantity.Unit, Double -> Double) -> Rule\n go (name, regexPattern, u, convert) = Rule\n { name = name\n , pattern = [ regex regexPattern ]\n , prod = \\_ -> Just . Token Quantity . quantity u $ convert 1\n }\n\nrules :: [Rule]\nrules = ruleNumeralQuantities ++ ruleAQuantity\n", "num_lines": 63} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Quantity.NL.Corpus\n ( corpus\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Locale\nimport Duckling.Quantity.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncontext :: Context\ncontext = testContext {locale = makeLocale NL Nothing}\n\ncorpus :: Corpus\ncorpus = (context, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple Gram 2 Nothing)\n [ \"2 gram\"\n , \"0,002 kg\"\n , \"0,002 kilo\"\n , \"2/1000 kilogram\"\n , \"2000 milligram\"\n ]\n , examples (simple Gram 1000 Nothing)\n [ \"1 kg\"\n , \"1,0 kg\"\n , \"1 kilogram\"\n , \"1 kilo\"\n , \"1000 gram\"\n , \"1000 g\"\n , \"1000 gr\"\n , \"duizend gram\"\n , \"duizend gr\"\n , \"2,0 pond\"\n , \"10 ons\"\n , \"1000000 mg\"\n , \"1000000 milligram\"\n ]\n , examples (simple Cup 1 (Just \"suiker\"))\n [ \"1 kopje suiker\"\n ]\n , examples (simple Cup 3 (Just \"suiker\"))\n [ \"3 kopjes suiker\"\n ]\n , examples (simple Cup 0.75 Nothing)\n [ \"3/4 kopje\"\n , \"0,75 kopje\"\n , \",75 kopje\"\n ]\n , examples (simple Gram 500 (Just \"aardbeien\"))\n [ \"500 gram aardbeien\"\n , \"500g aardbeien\"\n , \"0,5 kilogram aardbeien\"\n , \"0,5 kg aardbeien\"\n , \"5 ons aardbeien\"\n , \"1 pond aardbeien\"\n , \"500000mg aardbeien\"\n ]\n , examples (between Gram (100,1000) (Just \"aardbeien\"))\n [ \"100-1000 gram aardbeien\"\n , \"tussen 100 en 1000 gram aardbeien\"\n , \"van 100 tot 1000 g aardbeien\"\n , \"tussen 1 ons en 10 ons aardbeien\"\n , \"100 - 1000 g aardbeien\"\n ]\n , examples (between Gram (2,7) Nothing)\n [ \"~2-7 gram\"\n , \"van 2 tot 7 g\"\n , \"tussen 2,0 g en ongeveer 7,0 g\"\n , \"tussen 0,002 kg en ongeveer 0,007 kg\"\n , \"2 - ~7 gram\"\n ]\n ]\n", "num_lines": 87} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n{-# LANGUAGE LambdaCase #-}\n\nmodule Duckling.Quantity.NL.Rules\n ( rules\n ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport Data.String\nimport Data.Text (Text)\nimport Prelude\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers\nimport Duckling.Quantity.Helpers\nimport Duckling.Regex.Types (GroupMatch (..))\nimport Duckling.Types\nimport Duckling.Numeral.Types (NumeralData (..))\nimport Duckling.Quantity.Types (QuantityData(..))\nimport qualified Duckling.Numeral.Types as TNumeral\nimport qualified Duckling.Quantity.Types as TQuantity\n\nquantities :: [(Text, String, TQuantity.Unit)]\nquantities =\n [ (\" kopje\", \"(kopjes?)\", TQuantity.Cup)\n , (\" grams\", \"(g((r)?(am)?)?)\", TQuantity.Gram)\n , (\" milligrams\", \"((m(illi)?)(g(ram)?))\", TQuantity.Gram)\n , (\" kilograms\", \"((k(ilo)?)(g(ram)?)?)\", TQuantity.Gram)\n , (\" pond\", \"(pond(je(s)?)?)\", TQuantity.Gram)\n , (\" ons\", \"(ons(je(s)?)?)\", TQuantity.Gram)\n ]\n\nopsMap :: HashMap Text (Double -> Double)\nopsMap = HashMap.fromList\n [ ( \"milligram\" , (/ 1000))\n , ( \"mg\" , (/ 1000))\n , ( \"kilo\" , (* 1000))\n , ( \"kilogram\" , (* 1000))\n , ( \"kg\" , (* 1000))\n , ( \"pond\" , (* 500))\n , ( \"ons\" , (* 100))\n ]\n\nruleNumeralQuantities :: [Rule]\nruleNumeralQuantities = map go quantities\n where\n go :: (Text, String, TQuantity.Unit) -> Rule\n go (name, regexPattern, u) = Rule\n { name = name\n , pattern = [Predicate isPositive, regex regexPattern]\n , prod = \\case\n (Token Numeral nd:\n Token RegexMatch (GroupMatch (match:_)):\n _) -> Just . Token Quantity $ quantity u value\n where value = getValue opsMap match $ TNumeral.value nd\n _ -> Nothing\n }\n\nruleAQuantity :: [Rule]\nruleAQuantity = map go quantities\n where\n go :: (Text, String, TQuantity.Unit) -> Rule\n go (name, regexPattern, u) = Rule\n { name = name\n , pattern = [ regex (\"een? \" ++ regexPattern) ]\n , prod = \\case\n (Token RegexMatch (GroupMatch (match:_)):\n _) -> Just . Token Quantity $ quantity u $ getValue opsMap match 1\n _ -> Nothing\n }\n\nruleQuantityOfProduct :: Rule\nruleQuantityOfProduct = Rule\n { name = \" product\"\n , pattern =\n [ dimension Quantity\n , regex \"(\\\\w+)\"\n ]\n , prod = \\case\n (Token Quantity qd:Token RegexMatch (GroupMatch (product:_)):_) ->\n Just . Token Quantity $ withProduct (Text.toLower product) qd\n _ -> Nothing\n }\n\nrulePrecision :: Rule\nrulePrecision = Rule\n { name = \"ongeveer|plm|plusminus \"\n , pattern =\n [ regex \"\\\\~|precies|exact|ongeveer|bijna|ongeveer\"\n , dimension Quantity\n ]\n , prod = \\case\n (_:token:_) -> Just token\n _ -> Nothing\n }\n\nruleIntervalBetweenNumeral :: Rule\nruleIntervalBetweenNumeral = Rule\n { name = \"tussen|van en|tot \"\n , pattern =\n [ regex \"tussen|van\"\n , Predicate isPositive\n , regex \"tot|en\"\n , Predicate isSimpleQuantity\n ]\n , prod = \\case\n (_:\n Token Numeral NumeralData{TNumeral.value = from}:\n _:\n Token Quantity QuantityData{TQuantity.value = Just to\n , TQuantity.unit = Just u\n , TQuantity.aproduct = Nothing}:\n _) | from < to ->\n Just . Token Quantity . withInterval (from, to) $ unitOnly u\n _ -> Nothing\n }\n\nruleIntervalBetween :: Rule\nruleIntervalBetween = Rule\n { name = \"rond|tussen|van tot|en \"\n , pattern =\n [ regex \"tussen|van\"\n , Predicate isSimpleQuantity\n , regex \"en|tot\"\n , Predicate isSimpleQuantity\n ]\n , prod = \\case\n (_:\n Token Quantity QuantityData{TQuantity.value = Just from\n , TQuantity.unit = Just u1\n , TQuantity.aproduct = Nothing}:\n _:\n Token Quantity QuantityData{TQuantity.value = Just to\n , TQuantity.unit = Just u2\n , TQuantity.aproduct = Nothing}:\n _) | from < to && u1 == u2 ->\n Just . Token Quantity . withInterval (from, to) $ unitOnly u1\n _ -> Nothing\n }\n\nruleIntervalNumeralDash :: Rule\nruleIntervalNumeralDash = Rule\n { name = \" - \"\n , pattern =\n [ Predicate isPositive\n , regex \"\\\\-\"\n , Predicate isSimpleQuantity\n ]\n , prod = \\case\n (Token Numeral NumeralData{TNumeral.value = from}:\n _:\n Token Quantity QuantityData{TQuantity.value = Just to\n , TQuantity.unit = Just u\n , TQuantity.aproduct = Nothing}:\n _) | from < to ->\n Just . Token Quantity . withInterval (from, to) $ unitOnly u\n _ -> Nothing\n }\n\nruleIntervalDash :: Rule\nruleIntervalDash = Rule\n { name = \" - \"\n , pattern =\n [ Predicate isSimpleQuantity\n , regex \"\\\\-\"\n , Predicate isSimpleQuantity\n ]\n , prod = \\case\n (Token Quantity QuantityData{TQuantity.value = Just from\n , TQuantity.unit = Just u1\n , TQuantity.aproduct = Nothing}:\n _:\n Token Quantity QuantityData{TQuantity.value = Just to\n , TQuantity.unit = Just u2\n , TQuantity.aproduct = Nothing}:\n _) | from < to && u1 == u2 ->\n Just . Token Quantity . withInterval (from, to) $ unitOnly u1\n _ -> Nothing\n }\n\nruleIntervalMax :: Rule\nruleIntervalMax = Rule\n { name = \"minder dan/hoogstens/op zijn hoogst/maximaal/hooguit \"\n , pattern =\n [ regex \"minder dan|hoogstens|hooguit|maximaal|op zijn hoogst\"\n , Predicate isSimpleQuantity\n ]\n , prod = \\case\n (_:\n Token Quantity QuantityData{TQuantity.value = Just to\n , TQuantity.unit = Just u\n , TQuantity.aproduct = Nothing}:\n _) -> Just . Token Quantity . withMax to $ unitOnly u\n _ -> Nothing\n }\n\nruleIntervalMin :: Rule\nruleIntervalMin = Rule\n { name = \"meer dan/minstens/op zijn minst \"\n , pattern =\n [ regex \"meer dan|minstens|minimaal|op zijn minst|minder dan\"\n , Predicate isSimpleQuantity\n ]\n , prod = \\case\n (_:\n Token Quantity QuantityData{TQuantity.value = Just from\n , TQuantity.unit = Just u\n , TQuantity.aproduct = Nothing}:\n _) -> Just . Token Quantity . withMin from $ unitOnly u\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleQuantityOfProduct\n , ruleIntervalMin\n , ruleIntervalMax\n , ruleIntervalBetweenNumeral\n , ruleIntervalBetween\n , ruleIntervalNumeralDash\n , ruleIntervalDash\n , rulePrecision\n ]\n ++ ruleNumeralQuantities\n ++ ruleAQuantity\n", "num_lines": 236} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Quantity.PT.Corpus\n ( corpus ) where\n\nimport Prelude\nimport Data.String\n\nimport Duckling.Locale\nimport Duckling.Quantity.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale PT Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple Pound 2 (Just \"carne\"))\n [ \"duas libras de carne\"\n ]\n , examples (simple Gram 2 Nothing)\n [ \"2 gramas\"\n , \"0,002 kg\"\n , \"2 g\"\n , \"2/1000 quilogramas\"\n , \"2/1000 quilos\"\n , \"2000 miligramas\"\n , \"2000 miligramas\"\n ]\n , examples (simple Gram 1000 Nothing)\n [ \"um quilograma\"\n , \"um quilo\"\n , \"um kg\"\n , \"1 kg\"\n , \"1000 g\"\n ]\n , examples (simple Pound 1 Nothing)\n [ \"uma Libra\"\n , \"1 lb\"\n , \"uma lb\"\n ]\n , examples (simple Cup 3 (Just \"acucar\"))\n [ \"3 copos de acucar\"\n , \"3 copos de AcucAr\"\n ]\n , examples (simple Cup 0.75 Nothing)\n [ \"3/4 copo\"\n , \"0,75 copo\"\n ]\n , examples (simple Gram 500 (Just \"morangos\"))\n [ \"500 gramas de morangos\"\n , \"500g de morangos\"\n , \"0,5 quilos de morangos\"\n , \"0,5 kg de morangos\"\n , \"500000mg de morangos\"\n ]\n ]\n", "num_lines": 66} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE OverloadedStrings #-}\n{-# LANGUAGE LambdaCase #-}\n\nmodule Duckling.Quantity.PT.Rules\n ( rules ) where\n\nimport Data.HashMap.Strict (HashMap)\nimport qualified Data.HashMap.Strict as HashMap\nimport qualified Data.Text as Text\nimport Prelude\nimport Data.String\nimport Data.Text (Text)\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Types (NumeralData (..))\nimport qualified Duckling.Numeral.Types as TNumeral\nimport Duckling.Numeral.Helpers\nimport Duckling.Quantity.Helpers\nimport qualified Duckling.Quantity.Types as TQuantity\nimport Duckling.Regex.Types\nimport Duckling.Types\n\nquantities :: [(Text, String, TQuantity.Unit)]\nquantities =\n [ (\" copos\", \"(copos?)\", TQuantity.Cup)\n , (\" gramas\", \"((((mili)|(quilo))?(grama)s?)|(quilos?)|((m|k)?g))\", TQuantity.Gram)\n , (\" libras\", \"((lb|libra)s?)\", TQuantity.Pound)\n ]\n\nopsMap :: HashMap Text (Double -> Double)\nopsMap = HashMap.fromList\n [ ( \"miligrama\" , (/ 1000))\n , ( \"miligramas\" , (/ 1000))\n , ( \"mg\" , (/ 1000))\n , ( \"mgs\" , (/ 1000))\n , ( \"quilograma\" , (* 1000))\n , ( \"quilogramas\", (* 1000))\n , ( \"quilo\" , (* 1000))\n , ( \"quilos\" , (* 1000))\n , ( \"kg\" , (* 1000))\n , ( \"kgs\" , (* 1000))\n ]\n\nruleNumeralQuantities :: [Rule]\nruleNumeralQuantities = map go quantities\n where\n go :: (Text, String, TQuantity.Unit) -> Rule\n go (name, regexPattern, u) = Rule\n { name = name\n , pattern = [Predicate isPositive, regex regexPattern]\n , prod = \\case\n (Token Numeral nd:\n Token RegexMatch (GroupMatch (match:_)):\n _) -> do\n let value = getValue opsMap match $ TNumeral.value nd\n Just $ Token Quantity $ quantity u value\n _ -> Nothing\n }\n\nruleQuantityOfProduct :: Rule\nruleQuantityOfProduct = Rule\n { name = \" of product\"\n , pattern =\n [ dimension Quantity\n , regex \"de (\\\\w+)\"\n ]\n , prod = \\case\n (Token Quantity qd:Token RegexMatch (GroupMatch (product:_)):_) ->\n Just $ Token Quantity $ withProduct (Text.toLower product) qd\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleQuantityOfProduct ]\n ++ ruleNumeralQuantities\n", "num_lines": 85} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Quantity.RO.Corpus\n ( corpus\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Locale\nimport Duckling.Quantity.Types\nimport Duckling.Resolve\nimport Duckling.Testing.Types\n\ncorpus :: Corpus\ncorpus = (testContext {locale = makeLocale RO Nothing}, testOptions, allExamples)\n\nallExamples :: [Example]\nallExamples = concat\n [ examples (simple Pound 2 (Just \"carne\"))\n [ \"doua livre de carne\"\n ]\n , examples (simple Pound 1 Nothing)\n [ \"o livr\u00c4\u0192\"\n ]\n , examples (simple Pound 500 (Just \"zah\u00c4\u0192r\"))\n [ \"cinci sute livre de zah\u00c4\u0192r\"\n , \"cinci sute de livre de zah\u00c4\u0192r\"\n ]\n , examples (simple Pound 21 (Just \"mamaliga\"))\n [ \"dou\u00c4\u0192zeci \u00c8\u2122i unu de livre de mamaliga\"\n ]\n ]\n", "num_lines": 41} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\n{-# LANGUAGE LambdaCase #-}\n{-# LANGUAGE OverloadedStrings #-}\n\nmodule Duckling.Quantity.RO.Rules\n ( rules\n ) where\n\nimport Data.String\nimport Prelude\n\nimport Duckling.Dimensions.Types\nimport Duckling.Numeral.Helpers (isPositive)\nimport Duckling.Numeral.Types (NumeralData(..))\nimport Duckling.Quantity.Helpers\nimport Duckling.Regex.Types\nimport Duckling.Types\nimport qualified Duckling.Numeral.Types as TNumeral\nimport qualified Duckling.Quantity.Types as TQuantity\n\nruleNumeralUnits :: Rule\nruleNumeralUnits = Rule\n { name = \" \"\n , pattern =\n [ Predicate isPositive\n , regex \"(de )?livr(a|e|\u00c4\u0192)\"\n ]\n , prod = \\case\n (Token Numeral NumeralData {TNumeral.value = v}:_) ->\n Just . Token Quantity $ quantity TQuantity.Pound v\n _ -> Nothing\n }\n\nruleQuantityOfProduct :: Rule\nruleQuantityOfProduct = Rule\n { name = \" of product\"\n , pattern =\n [ dimension Quantity\n , regex \"de (carne|can[a\u00c4\u0192]|zah[a\u00c4\u0192]r|mamaliga)\"\n ]\n , prod = \\case\n (Token Quantity qd:\n Token RegexMatch (GroupMatch (product:_)):\n _) -> Just . Token Quantity $ withProduct product qd\n _ -> Nothing\n }\n\nrules :: [Rule]\nrules =\n [ ruleNumeralUnits\n , ruleQuantityOfProduct\n ]\n", "num_lines": 60} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\nmodule Duckling.Ranking.Classifiers\n ( classifiers\n ) where\n\nimport Data.Maybe\n\nimport Duckling.Locale\nimport Duckling.Ranking.Types\nimport qualified Duckling.Ranking.Classifiers.AF_XX as AF_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.AR_XX as AR_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.BG_XX as BG_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.BN_XX as BN_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.CA_XX as CA_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.CS_XX as CS_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.DA_XX as DA_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.DE_XX as DE_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.EL_XX as EL_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.EN_GB as EN_GBClassifiers\nimport qualified Duckling.Ranking.Classifiers.EN_US as EN_USClassifiers\nimport qualified Duckling.Ranking.Classifiers.EN_XX as EN_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.ES_XX as ES_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.ET_XX as ET_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.FI_XX as FI_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.FA_XX as FA_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.FR_XX as FR_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.GA_XX as GA_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.HE_XX as HE_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.HI_XX as HI_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.HR_XX as HR_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.HU_XX as HU_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.ID_XX as ID_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.IS_XX as IS_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.IT_XX as IT_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.JA_XX as JA_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.KA_XX as KA_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.KM_XX as KM_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.KN_XX as KN_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.KO_XX as KO_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.LO_XX as LO_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.ML_XX as ML_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.MN_XX as MN_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.MY_XX as MY_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.NB_XX as NB_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.NE_XX as NE_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.NL_XX as NL_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.PL_XX as PL_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.PT_XX as PT_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.RO_XX as RO_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.RU_XX as RU_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.SK_XX as SK_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.SV_XX as SV_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.SW_XX as SW_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.TA_XX as TA_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.TE_XX as TE_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.TH_XX as TH_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.TR_XX as TR_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.UK_XX as UK_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.VI_XX as VI_XXClassifiers\nimport qualified Duckling.Ranking.Classifiers.ZH_XX as ZH_XXClassifiers\n\nclassifiers :: Locale -> Classifiers\nclassifiers (Locale AF _) = AF_XXClassifiers.classifiers\nclassifiers (Locale AR _) = AR_XXClassifiers.classifiers\nclassifiers (Locale BG _) = BG_XXClassifiers.classifiers\nclassifiers (Locale BN _) = BN_XXClassifiers.classifiers\nclassifiers (Locale CA _) = CA_XXClassifiers.classifiers\nclassifiers (Locale CS _) = CS_XXClassifiers.classifiers\nclassifiers (Locale DA _) = DA_XXClassifiers.classifiers\nclassifiers (Locale DE _) = DE_XXClassifiers.classifiers\nclassifiers (Locale EL _) = EL_XXClassifiers.classifiers\nclassifiers (Locale EN (Just GB)) = EN_GBClassifiers.classifiers\nclassifiers (Locale EN (Just US)) = EN_USClassifiers.classifiers\nclassifiers (Locale EN _) = EN_XXClassifiers.classifiers\nclassifiers (Locale ES _) = ES_XXClassifiers.classifiers\nclassifiers (Locale ET _) = ET_XXClassifiers.classifiers\nclassifiers (Locale FI _) = FI_XXClassifiers.classifiers\nclassifiers (Locale FA _) = FA_XXClassifiers.classifiers\nclassifiers (Locale FR _) = FR_XXClassifiers.classifiers\nclassifiers (Locale GA _) = GA_XXClassifiers.classifiers\nclassifiers (Locale HE _) = HE_XXClassifiers.classifiers\nclassifiers (Locale HI _) = HI_XXClassifiers.classifiers\nclassifiers (Locale HR _) = HR_XXClassifiers.classifiers\nclassifiers (Locale HU _) = HU_XXClassifiers.classifiers\nclassifiers (Locale ID _) = ID_XXClassifiers.classifiers\nclassifiers (Locale IS _) = IS_XXClassifiers.classifiers\nclassifiers (Locale IT _) = IT_XXClassifiers.classifiers\nclassifiers (Locale JA _) = JA_XXClassifiers.classifiers\nclassifiers (Locale KA _) = KA_XXClassifiers.classifiers\nclassifiers (Locale KM _) = KM_XXClassifiers.classifiers\nclassifiers (Locale KN _) = KN_XXClassifiers.classifiers\nclassifiers (Locale KO _) = KO_XXClassifiers.classifiers\nclassifiers (Locale LO _) = LO_XXClassifiers.classifiers\nclassifiers (Locale ML _) = ML_XXClassifiers.classifiers\nclassifiers (Locale MN _) = MN_XXClassifiers.classifiers\nclassifiers (Locale MY _) = MY_XXClassifiers.classifiers\nclassifiers (Locale NB _) = NB_XXClassifiers.classifiers\nclassifiers (Locale NE _) = NE_XXClassifiers.classifiers\nclassifiers (Locale NL _) = NL_XXClassifiers.classifiers\nclassifiers (Locale PL _) = PL_XXClassifiers.classifiers\nclassifiers (Locale PT _) = PT_XXClassifiers.classifiers\nclassifiers (Locale RO _) = RO_XXClassifiers.classifiers\nclassifiers (Locale RU _) = RU_XXClassifiers.classifiers\nclassifiers (Locale SK _) = SK_XXClassifiers.classifiers\nclassifiers (Locale SV _) = SV_XXClassifiers.classifiers\nclassifiers (Locale SW _) = SW_XXClassifiers.classifiers\nclassifiers (Locale TA _) = TA_XXClassifiers.classifiers\nclassifiers (Locale TE _) = TE_XXClassifiers.classifiers\nclassifiers (Locale TH _) = TH_XXClassifiers.classifiers\nclassifiers (Locale TR _) = TR_XXClassifiers.classifiers\nclassifiers (Locale UK _) = UK_XXClassifiers.classifiers\nclassifiers (Locale VI _) = VI_XXClassifiers.classifiers\nclassifiers (Locale ZH _) = ZH_XXClassifiers.classifiers\n", "num_lines": 120} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE GADTs #-}\nmodule Duckling.Ranking.Extraction\n ( extractFeatures\n ) where\n\nimport qualified Data.HashMap.Strict as HashMap\nimport Data.Maybe\nimport qualified Data.Text as Text\nimport Prelude\nimport TextShow (showt)\n\nimport Duckling.Dimensions.Types\nimport Duckling.Duration.Types (DurationData (DurationData))\nimport qualified Duckling.Duration.Types as TDuration\nimport Duckling.Ranking.Types (BagOfFeatures)\nimport Duckling.Time.Types (TimeData (TimeData))\nimport qualified Duckling.Time.Types as TTime\nimport Duckling.Types (Node, Token(..), rule, children, token)\n\n\n-- | Feature extraction\n-- | Features:\n-- | 1) Concatenation of the names of the rules involved in parsing `Node`\n-- | 2) Concatenation of the grains for time-like dimensions\nextractFeatures :: Node -> BagOfFeatures\nextractFeatures node =\n HashMap.fromList $ (featRules, 1) : [ (featGrain, 1) | not (null grains) ]\n where\n featRules = Text.concat $ mapMaybe rule (children node)\n grains = mapMaybe (\\x ->\n case token x of\n Token Duration DurationData{TDuration.grain = g} -> Just $ showt g\n Token Time TimeData{TTime.timeGrain = g} -> Just $ showt g\n Token TimeGrain g -> Just $ showt g\n _ -> Nothing\n ) $ children node\n featGrain = Text.concat grains\n", "num_lines": 45} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE RecordWildCards #-}\n{-# LANGUAGE NoRebindableSyntax #-}\n\nmodule Duckling.Ranking.Rank\n ( rank\n ) where\n\nimport qualified Data.HashMap.Strict as HashMap\nimport Data.HashSet (HashSet)\nimport qualified Data.HashSet as HashSet\nimport Data.Maybe\nimport qualified Data.Set as Set\nimport Prelude\n\nimport Duckling.Dimensions.Types\nimport Duckling.Ranking.Extraction\nimport Duckling.Ranking.Types\nimport Duckling.Types\n\n-- | computes log likelihood of a class\nll :: BagOfFeatures -> ClassData -> Double\nll feats ClassData{..} =\n prior +\n HashMap.foldrWithKey\n (\\feat x res ->\n res + fromIntegral x * HashMap.lookupDefault unseen feat likelihoods)\n 0.0\n feats\n\n-- | computes positive class log likelihood\nposLL :: Classifier -> BagOfFeatures -> Double\nposLL Classifier {..} feats = ll feats okData\n\nscore :: Classifiers -> Node -> Double\nscore classifiers node@Node {rule = Just rule, ..} =\n case HashMap.lookup rule classifiers of\n Just c -> let feats = extractFeatures node\n in posLL c feats + sum (map (score classifiers) children)\n Nothing -> 0.0\nscore _ Node {rule = Nothing} = 0.0\n\n-- | Return all superior candidates, as defined by the partial ordering\nwinners :: Ord a => [a] -> [a]\nwinners xs = filter (\\x -> all ((/=) LT . compare x) xs) xs\n\n-- | Return a curated list of tokens\nrank\n :: Classifiers\n -> HashSet (Seal Dimension)\n -> [ResolvedToken]\n -> [ResolvedToken]\nrank classifiers targets tokens =\n Set.toList\n $ Set.fromList\n $ map (\\(Candidate token _ _) -> token)\n $ winners\n $ map makeCandidate tokens\n where\n makeCandidate :: ResolvedToken -> Candidate\n makeCandidate token@Resolved {node = n@Node {token = Token d _}} =\n Candidate token (score classifiers n) $ HashSet.member (Seal d) targets\n", "num_lines": 69} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree.\n\n\n{-# LANGUAGE NoRebindableSyntax #-}\n\n\nmodule Duckling.Ranking.Types\n ( Feature\n , BagOfFeatures\n , Class\n , Datum\n , Dataset\n\n , Classifier(..)\n , Classifiers\n , ClassData(..)\n , Candidate(..)\n\n , infinity\n ) where\nimport Data.HashMap.Strict (HashMap)\nimport Data.Text (Text)\nimport Prelude\nimport Duckling.Types\n ( Node(..)\n , Range(..)\n , ResolvedToken(..)\n , Token(..)\n , isDimension\n )\n\n-- -----------------------------------------------------------------\n-- Aliases\n\ntype Feature = Text\ntype BagOfFeatures = HashMap Feature Int\ntype Class = Bool\ntype Datum = (BagOfFeatures, Class)\ntype Dataset = HashMap Text [Datum]\n\n-- -----------------------------------------------------------------\n-- Classification\n\ndata Classifier = Classifier\n { okData :: ClassData\n , koData :: ClassData\n }\n deriving (Eq, Show)\n\ntype Classifiers = HashMap Text Classifier\n\ndata ClassData = ClassData\n { prior :: Double\n , unseen :: Double\n , likelihoods :: HashMap Feature Double\n , n :: Int\n }\n deriving (Eq, Show)\n\ninfinity :: Double\ninfinity = 1 / 0\n\n-- -----------------------------------------------------------------\n-- Candidate\n\n-- |A Candidate represents a potential match going into the ranker\ndata Candidate = Candidate\n ResolvedToken -- ^ The actual resolved token we are considering\n Double -- ^ naive Bayes log-likelihood - sum of LL of all rules used\n Bool -- ^ Does the ResolvedToken's dimension match the caller's request?\n deriving (Eq, Show)\n\ninstance Ord Candidate where\n compare (Candidate Resolved{range = Range s1 e1, node = Node{token = Token d1 _}} score1 t1)\n (Candidate Resolved{range = Range s2 e2, node = Node{token = tok2}} score2 t2)\n | isDimension d1 tok2 = case starts of\n EQ -> case ends of\n EQ -> compare score1 score2\n z -> z\n LT -> case ends of\n LT -> EQ\n _ -> GT\n GT -> case ends of\n GT -> EQ\n _ -> LT\n | t1 == t2 = compRange\n | t1 && compRange == GT = GT\n | t2 && compRange == LT = LT\n | otherwise = EQ\n where\n starts = compare s1 s2\n ends = compare e1 e2\n -- a > b if a recovers b\n compRange = case starts of\n EQ -> ends\n LT -> case ends of\n LT -> EQ\n _ -> GT\n GT -> case ends of\n GT -> EQ\n _ -> LT\n", "num_lines": 106} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree. An additional grant\n-- of patent rights can be found in the PATENTS file in the same directory.\n\n-----------------------------------------------------------------\n-- Auto-generated by regenClassifiers\n--\n-- DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING\n-- @generated\n-----------------------------------------------------------------\n{-# LANGUAGE OverloadedStrings #-}\nmodule Duckling.Ranking.Classifiers.AF_XX (classifiers) where\nimport Data.String\nimport Prelude\nimport qualified Data.HashMap.Strict as HashMap\nimport Duckling.Ranking.Types\n\nclassifiers :: Classifiers\nclassifiers = HashMap.fromList []", "num_lines": 22} {"repo_name": "duckling", "repo_creator": "facebook", "programming_language": "Haskell", "code": "-- Copyright (c) 2016-present, Facebook, Inc.\n-- All rights reserved.\n--\n-- This source code is licensed under the BSD-style license found in the\n-- LICENSE file in the root directory of this source tree. An additional grant\n-- of patent rights can be found in the PATENTS file in the same directory.\n\n-----------------------------------------------------------------\n-- Auto-generated by regenClassifiers\n--\n-- DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING\n-- @generated\n-----------------------------------------------------------------\n{-# LANGUAGE OverloadedStrings #-}\nmodule Duckling.Ranking.Classifiers.AR_EG (classifiers) where\nimport Data.String\nimport Prelude\nimport qualified Data.HashMap.Strict as HashMap\nimport Duckling.Ranking.Types\n\nclassifiers :: Classifiers\nclassifiers\n = HashMap.fromList\n [(\"