duckling 0.1.2.0 → 0.1.3.0

raw patch · 448 files changed

+45843/−31452 lines, 448 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

This diff is very large; some files are shown as “too large to diff”. Download the raw patch for the complete diff.

Files

• Duckling/AmountOfMoney/BG/Corpus.hs +120/−0
• Duckling/AmountOfMoney/BG/Rules.hs +267/−0
• Duckling/AmountOfMoney/EN/Corpus.hs +6/−2
• Duckling/AmountOfMoney/ES/Corpus.hs +5/−4
• Duckling/AmountOfMoney/ES/Rules.hs +1/−1
• Duckling/AmountOfMoney/FR/Corpus.hs +5/−4
• Duckling/AmountOfMoney/FR/Rules.hs +1/−1
• Duckling/AmountOfMoney/GA/Corpus.hs +5/−4
• Duckling/AmountOfMoney/GA/Rules.hs +2/−2
• Duckling/AmountOfMoney/HR/Corpus.hs +5/−4
• Duckling/AmountOfMoney/HR/Rules.hs +1/−1
• Duckling/AmountOfMoney/ID/Corpus.hs +5/−4
• Duckling/AmountOfMoney/ID/Rules.hs +1/−1
• Duckling/AmountOfMoney/KO/Corpus.hs +5/−4
• Duckling/AmountOfMoney/KO/Rules.hs +10/−10
• Duckling/AmountOfMoney/NB/Corpus.hs +5/−4
• Duckling/AmountOfMoney/NB/Rules.hs +1/−1
• Duckling/AmountOfMoney/PT/Corpus.hs +5/−4
• Duckling/AmountOfMoney/RO/Corpus.hs +5/−4
• Duckling/AmountOfMoney/RO/Rules.hs +5/−5
• Duckling/AmountOfMoney/Rules.hs +10/−9
• Duckling/AmountOfMoney/SV/Corpus.hs +5/−4
• Duckling/AmountOfMoney/SV/Rules.hs +1/−1
• Duckling/AmountOfMoney/Types.hs +2/−0
• Duckling/AmountOfMoney/VI/Corpus.hs +5/−4
• Duckling/AmountOfMoney/VI/Rules.hs +5/−5
• Duckling/Api.hs +6/−6
• Duckling/Core.hs +6/−2
• Duckling/Debug.hs +9/−9
• Duckling/Dimensions.hs +7/−1
• Duckling/Dimensions/BG.hs +18/−0
• Duckling/Dimensions/HU.hs +21/−0
• Duckling/Dimensions/KA.hs +17/−0
• Duckling/Dimensions/NL.hs +1/−0
• Duckling/Distance/CS/Corpus.hs +4/−3
• Duckling/Distance/ES/Corpus.hs +5/−4
• Duckling/Distance/ES/Rules.hs +2/−2
• Duckling/Distance/FR/Corpus.hs +2/−2
• Duckling/Distance/FR/Rules.hs +3/−3
• Duckling/Distance/GA/Corpus.hs +2/−2
• Duckling/Distance/GA/Rules.hs +5/−5
• Duckling/Distance/HR/Corpus.hs +2/−2
• Duckling/Distance/KO/Corpus.hs +2/−2
• Duckling/Distance/KO/Rules.hs +10/−10
• Duckling/Distance/NL/Corpus.hs +2/−2
• Duckling/Distance/PT/Corpus.hs +2/−2
• Duckling/Distance/PT/Rules.hs +2/−2
• Duckling/Distance/RO/Corpus.hs +2/−2
• Duckling/Distance/RO/Rules.hs +1/−1
• Duckling/Distance/TR/Corpus.hs +2/−2
• Duckling/Duration/DA/Rules.hs +1/−1
• Duckling/Duration/DE/Rules.hs +1/−1
• Duckling/Duration/FR/Corpus.hs +3/−3
• Duckling/Duration/GA/Corpus.hs +2/−2
• Duckling/Duration/GA/Rules.hs +1/−1
• Duckling/Duration/HE/Rules.hs +7/−7
• Duckling/Duration/HR/Rules.hs +4/−4
• Duckling/Duration/HU/Corpus.hs +74/−0
• Duckling/Duration/HU/Rules.hs +91/−0
• Duckling/Duration/JA/Corpus.hs +2/−2
• Duckling/Duration/KO/Corpus.hs +2/−2
• Duckling/Duration/KO/Rules.hs +6/−6
• Duckling/Duration/NB/Corpus.hs +2/−2
• Duckling/Duration/NL/Corpus.hs +83/−0
• Duckling/Duration/NL/Rules.hs +114/−0
• Duckling/Duration/PL/Corpus.hs +2/−2
• Duckling/Duration/PL/Rules.hs +4/−4
• Duckling/Duration/PT/Corpus.hs +2/−2
• Duckling/Duration/RO/Corpus.hs +2/−2
• Duckling/Duration/RO/Rules.hs +4/−4
• Duckling/Duration/SV/Corpus.hs +2/−2
• Duckling/Duration/TR/Corpus.hs +2/−2
• Duckling/Duration/TR/Rules.hs +4/−4
• Duckling/Duration/ZH/Corpus.hs +4/−2
• Duckling/Email/Corpus.hs +1/−1
• Duckling/Email/EN/Corpus.hs +10/−0
• Duckling/Email/EN/Rules.hs +3/−3
• Duckling/Email/FR/Corpus.hs +2/−2
• Duckling/Email/IT/Corpus.hs +2/−2
• Duckling/Engine.hs +6/−6
• Duckling/Lang.hs +0/−55
• Duckling/Locale.hs +106/−0
• Duckling/Numeral/AR/Corpus.hs +2/−2
• Duckling/Numeral/AR/Rules.hs +43/−43
• Duckling/Numeral/BG/Corpus.hs +127/−0
• Duckling/Numeral/BG/Rules.hs +273/−0
• Duckling/Numeral/CS/Corpus.hs +2/−2
• Duckling/Numeral/CS/Rules.hs +3/−3
• Duckling/Numeral/DA/Corpus.hs +2/−2
• Duckling/Numeral/DA/Rules.hs +5/−5
• Duckling/Numeral/DE/Corpus.hs +2/−2
• Duckling/Numeral/DE/Rules.hs +14/−14
• Duckling/Numeral/EN/Rules.hs +1/−1
• Duckling/Numeral/ES/Corpus.hs +2/−2
• Duckling/Numeral/ES/Rules.hs +9/−9
• Duckling/Numeral/ET/Corpus.hs +2/−2
• Duckling/Numeral/ET/Rules.hs +20/−20
• Duckling/Numeral/FR/Corpus.hs +2/−2
• Duckling/Numeral/FR/Rules.hs +3/−3
• Duckling/Numeral/GA/Corpus.hs +2/−2
• Duckling/Numeral/GA/Rules.hs +28/−28
• Duckling/Numeral/HE/Corpus.hs +2/−2
• Duckling/Numeral/HE/Rules.hs +34/−34
• Duckling/Numeral/HR/Corpus.hs +2/−2
• Duckling/Numeral/HR/Rules.hs +6/−6
• Duckling/Numeral/HU/Corpus.hs +98/−0
• Duckling/Numeral/HU/Rules.hs +169/−0
• Duckling/Numeral/ID/Corpus.hs +2/−2
• Duckling/Numeral/ID/Rules.hs +1/−1
• Duckling/Numeral/IT/Corpus.hs +2/−2
• Duckling/Numeral/IT/Rules.hs +10/−10
• Duckling/Numeral/JA/Corpus.hs +2/−2
• Duckling/Numeral/JA/Rules.hs +38/−56
• Duckling/Numeral/KA/Corpus.hs +43/−0
• Duckling/Numeral/KA/Rules.hs +75/−0
• Duckling/Numeral/KO/Corpus.hs +2/−2
• Duckling/Numeral/KO/Rules.hs +60/−60
• Duckling/Numeral/MY/Corpus.hs +2/−2
• Duckling/Numeral/MY/Rules.hs +33/−33
• Duckling/Numeral/NB/Corpus.hs +2/−2
• Duckling/Numeral/NB/Rules.hs +9/−9
• Duckling/Numeral/NL/Corpus.hs +9/−2
• Duckling/Numeral/NL/Rules.hs +14/−4
• Duckling/Numeral/PL/Corpus.hs +2/−2
• Duckling/Numeral/PL/Rules.hs +28/−28
• Duckling/Numeral/PT/Corpus.hs +2/−2
• Duckling/Numeral/PT/Rules.hs +5/−5
• Duckling/Numeral/RO/Corpus.hs +2/−2
• Duckling/Numeral/RO/Rules.hs +12/−12
• Duckling/Numeral/RU/Corpus.hs +2/−2
• Duckling/Numeral/RU/Rules.hs +49/−49
• Duckling/Numeral/SV/Corpus.hs +2/−2
• Duckling/Numeral/SV/Rules.hs +7/−7
• Duckling/Numeral/TR/Corpus.hs +2/−2
• Duckling/Numeral/TR/Rules.hs +234/−234
• Duckling/Numeral/UK/Corpus.hs +2/−2
• Duckling/Numeral/UK/Rules.hs +49/−49
• Duckling/Numeral/VI/Corpus.hs +2/−2
• Duckling/Numeral/VI/Rules.hs +60/−60
• Duckling/Numeral/ZH/Corpus.hs +2/−2
• Duckling/Numeral/ZH/Rules.hs +19/−19
• Duckling/Ordinal/AR/Corpus.hs +2/−2
• Duckling/Ordinal/AR/Rules.hs +10/−10
• Duckling/Ordinal/DA/Corpus.hs +2/−2
• Duckling/Ordinal/DA/Rules.hs +2/−2
• Duckling/Ordinal/DE/Corpus.hs +3/−3
• Duckling/Ordinal/DE/Rules.hs +6/−6
• Duckling/Ordinal/ES/Corpus.hs +42/−0
• Duckling/Ordinal/ES/Rules.hs +9/−9
• Duckling/Ordinal/ET/Corpus.hs +2/−2
• Duckling/Ordinal/ET/Rules.hs +12/−12
• Duckling/Ordinal/FR/Corpus.hs +2/−2
• Duckling/Ordinal/FR/Rules.hs +18/−18
• Duckling/Ordinal/GA/Corpus.hs +2/−2
• Duckling/Ordinal/GA/Rules.hs +46/−46
• Duckling/Ordinal/HE/Corpus.hs +2/−2
• Duckling/Ordinal/HE/Rules.hs +29/−29
• Duckling/Ordinal/HR/Corpus.hs +2/−2
• Duckling/Ordinal/HR/Rules.hs +1/−1
• Duckling/Ordinal/HU/Corpus.hs +67/−0
• Duckling/Ordinal/HU/Rules.hs +119/−0
• Duckling/Ordinal/ID/Corpus.hs +2/−2
• Duckling/Ordinal/IT/Corpus.hs +2/−2
• Duckling/Ordinal/IT/Rules.hs +1/−1
• Duckling/Ordinal/JA/Corpus.hs +2/−2
• Duckling/Ordinal/JA/Rules.hs +1/−1
• Duckling/Ordinal/KO/Corpus.hs +2/−2
• Duckling/Ordinal/KO/Rules.hs +1/−1
• Duckling/Ordinal/NB/Corpus.hs +2/−2
• Duckling/Ordinal/NB/Rules.hs +5/−5
• Duckling/Ordinal/NL/Corpus.hs +2/−2
• Duckling/Ordinal/PL/Corpus.hs +2/−2
• Duckling/Ordinal/PL/Rules.hs +27/−27
• Duckling/Ordinal/PT/Corpus.hs +2/−2
• Duckling/Ordinal/PT/Rules.hs +9/−9
• Duckling/Ordinal/RO/Corpus.hs +2/−2
• Duckling/Ordinal/RO/Rules.hs +2/−2
• Duckling/Ordinal/RU/Corpus.hs +2/−2
• Duckling/Ordinal/RU/Rules.hs +41/−41
• Duckling/Ordinal/SV/Corpus.hs +51/−13
• Duckling/Ordinal/SV/Rules.hs +75/−53
• Duckling/Ordinal/TR/Corpus.hs +2/−2
• Duckling/Ordinal/TR/Rules.hs +13/−13
• Duckling/Ordinal/UK/Corpus.hs +2/−2
• Duckling/Ordinal/UK/Rules.hs +32/−32
• Duckling/Ordinal/VI/Corpus.hs +2/−2
• Duckling/Ordinal/VI/Rules.hs +1/−1
• Duckling/Ordinal/ZH/Corpus.hs +2/−2
• Duckling/Ordinal/ZH/Rules.hs +1/−1
• Duckling/PhoneNumber/PT/Corpus.hs +2/−2
• Duckling/Quantity/EN/Corpus.hs +19/−0
• Duckling/Quantity/EN/Rules.hs +51/−45
• Duckling/Quantity/FR/Corpus.hs +2/−2
• Duckling/Quantity/FR/Rules.hs +2/−2
• Duckling/Quantity/HR/Corpus.hs +2/−2
• Duckling/Quantity/KO/Corpus.hs +2/−2
• Duckling/Quantity/KO/Rules.hs +13/−13
• Duckling/Quantity/PT/Corpus.hs +2/−2
• Duckling/Quantity/PT/Rules.hs +1/−1
• Duckling/Quantity/RO/Corpus.hs +2/−2
• Duckling/Quantity/RO/Rules.hs +2/−2
• Duckling/Quantity/Types.hs +1/−0
• Duckling/Ranking/Classifiers.hs +68/−56
• Duckling/Ranking/Classifiers/AR.hs +0/−22
• Duckling/Ranking/Classifiers/AR_XX.hs +22/−0
• Duckling/Ranking/Classifiers/BG_XX.hs +22/−0
• Duckling/Ranking/Classifiers/CS.hs +0/−22
• Duckling/Ranking/Classifiers/CS_XX.hs +22/−0
• Duckling/Ranking/Classifiers/DA.hs +0/−1566
• Duckling/Ranking/Classifiers/DA_XX.hs +1670/−0
• Duckling/Ranking/Classifiers/DE.hs +0/−1934
• Duckling/Ranking/Classifiers/DE_XX.hs +2063/−0
• Duckling/Ranking/Classifiers/EN.hs +0/−2190
• Duckling/Ranking/Classifiers/EN_CA.hs +2349/−0
• Duckling/Ranking/Classifiers/EN_GB.hs +2345/−0
• Duckling/Ranking/Classifiers/EN_US.hs +2349/−0
• Duckling/Ranking/Classifiers/EN_XX.hs +2349/−0
• Duckling/Ranking/Classifiers/ES.hs +0/−1160
• Duckling/Ranking/Classifiers/ES_XX.hs +1248/−0
• Duckling/Ranking/Classifiers/ET.hs +0/−22
• Duckling/Ranking/Classifiers/ET_XX.hs +22/−0
• Duckling/Ranking/Classifiers/FR.hs +0/−2601
• Duckling/Ranking/Classifiers/FR_XX.hs +2701/−0
• Duckling/Ranking/Classifiers/GA.hs +0/−155
• Duckling/Ranking/Classifiers/GA_XX.hs +156/−0
• Duckling/Ranking/Classifiers/HE.hs +0/−992
• Duckling/Ranking/Classifiers/HE_XX.hs +1051/−0
• Duckling/Ranking/Classifiers/HR.hs +0/−1849
• Duckling/Ranking/Classifiers/HR_XX.hs +1971/−0
• Duckling/Ranking/Classifiers/HU_XX.hs +318/−0
• Duckling/Ranking/Classifiers/ID.hs +0/−22
• Duckling/Ranking/Classifiers/ID_XX.hs +22/−0
• Duckling/Ranking/Classifiers/IT.hs +0/−2085
• Duckling/Ranking/Classifiers/IT_XX.hs +2226/−0
• Duckling/Ranking/Classifiers/JA.hs +0/−22
• Duckling/Ranking/Classifiers/JA_XX.hs +22/−0
• Duckling/Ranking/Classifiers/KA_XX.hs +22/−0
• Duckling/Ranking/Classifiers/KO.hs +0/−1458
• Duckling/Ranking/Classifiers/KO_XX.hs +1444/−0
• Duckling/Ranking/Classifiers/MY.hs +0/−22
• Duckling/Ranking/Classifiers/MY_XX.hs +22/−0
• Duckling/Ranking/Classifiers/NB.hs +0/−1603
• Duckling/Ranking/Classifiers/NB_XX.hs +1700/−0
• Duckling/Ranking/Classifiers/NL.hs +0/−22
• Duckling/Ranking/Classifiers/NL_XX.hs +22/−0
• Duckling/Ranking/Classifiers/PL.hs +0/−2284
• Duckling/Ranking/Classifiers/PL_XX.hs +2302/−0
• Duckling/Ranking/Classifiers/PT.hs +0/−1279
• Duckling/Ranking/Classifiers/PT_XX.hs +1338/−0
• Duckling/Ranking/Classifiers/RO.hs +0/−265
• Duckling/Ranking/Classifiers/RO_XX.hs +286/−0
• Duckling/Ranking/Classifiers/RU.hs +0/−22
• Duckling/Ranking/Classifiers/RU_XX.hs +22/−0
• Duckling/Ranking/Classifiers/SV.hs +0/−1596
• Duckling/Ranking/Classifiers/SV_XX.hs +1635/−0
• Duckling/Ranking/Classifiers/TR.hs +0/−22
• Duckling/Ranking/Classifiers/TR_XX.hs +22/−0
• Duckling/Ranking/Classifiers/UK.hs +0/−22
• Duckling/Ranking/Classifiers/UK_XX.hs +22/−0
• Duckling/Ranking/Classifiers/VI.hs +0/−906
• Duckling/Ranking/Classifiers/VI_XX.hs +969/−0
• Duckling/Ranking/Classifiers/ZH.hs +0/−827
• Duckling/Ranking/Classifiers/ZH_CN.hs +879/−0
• Duckling/Ranking/Classifiers/ZH_HK.hs +879/−0
• Duckling/Ranking/Classifiers/ZH_MO.hs +879/−0
• Duckling/Ranking/Classifiers/ZH_TW.hs +879/−0
• Duckling/Ranking/Classifiers/ZH_XX.hs +864/−0
• Duckling/Resolve.hs +2/−2
• Duckling/Rules.hs +113/−39
• Duckling/Rules/AR.hs +26/−17
• Duckling/Rules/BG.hs +44/−0
• Duckling/Rules/CS.hs +25/−16
• Duckling/Rules/Common.hs +4/−4
• Duckling/Rules/DA.hs +26/−17
• Duckling/Rules/DE.hs +26/−17
• Duckling/Rules/EN.hs +39/−17
• Duckling/Rules/ES.hs +26/−17
• Duckling/Rules/ET.hs +26/−17
• Duckling/Rules/FR.hs +26/−17
• Duckling/Rules/GA.hs +26/−17
• Duckling/Rules/HE.hs +25/−16
• Duckling/Rules/HR.hs +26/−16
• Duckling/Rules/HU.hs +47/−0
• Duckling/Rules/ID.hs +27/−18
• Duckling/Rules/IT.hs +26/−17
• Duckling/Rules/JA.hs +26/−17
• Duckling/Rules/KA.hs +43/−0
• Duckling/Rules/KO.hs +26/−17
• Duckling/Rules/MY.hs +26/−17
• Duckling/Rules/NB.hs +26/−17
• Duckling/Rules/NL.hs +28/−17
• Duckling/Rules/PL.hs +26/−17
• Duckling/Rules/PT.hs +26/−17
• Duckling/Rules/RO.hs +26/−17
• Duckling/Rules/RU.hs +26/−17
• Duckling/Rules/SV.hs +26/−17
• Duckling/Rules/TR.hs +25/−16
• Duckling/Rules/UK.hs +26/−17
• Duckling/Rules/VI.hs +25/−16
• Duckling/Rules/ZH.hs +34/−17
• Duckling/Temperature/ES/Corpus.hs +2/−2
• Duckling/Temperature/ES/Rules.hs +2/−2
• Duckling/Temperature/FR/Corpus.hs +2/−2
• Duckling/Temperature/FR/Rules.hs +2/−2
• Duckling/Temperature/GA/Corpus.hs +2/−2
• Duckling/Temperature/GA/Rules.hs +3/−3
• Duckling/Temperature/HR/Corpus.hs +2/−2
• Duckling/Temperature/HR/Rules.hs +1/−1
• Duckling/Temperature/IT/Corpus.hs +2/−2
• Duckling/Temperature/IT/Rules.hs +1/−1
• Duckling/Temperature/JA/Corpus.hs +2/−2
• Duckling/Temperature/JA/Rules.hs +7/−7
• Duckling/Temperature/KO/Corpus.hs +2/−2
• Duckling/Temperature/KO/Rules.hs +3/−3
• Duckling/Temperature/PT/Corpus.hs +2/−2
• Duckling/Temperature/PT/Rules.hs +3/−3
• Duckling/Temperature/RO/Corpus.hs +2/−2
• Duckling/Temperature/RO/Rules.hs +1/−1
• Duckling/Temperature/TR/Corpus.hs +2/−2
• Duckling/Temperature/ZH/Corpus.hs +2/−2
• Duckling/Temperature/ZH/Rules.hs +7/−7
• Duckling/Testing/Types.hs +8/−1
• Duckling/Time/DA/Corpus.hs +6/−5
• Duckling/Time/DA/Rules.hs +81/−226
• Duckling/Time/DE/Corpus.hs +8/−7
• Duckling/Time/DE/Rules.hs +156/−484
• Duckling/Time/EN/CA/Corpus.hs +60/−0
• Duckling/Time/EN/CA/Rules.hs +69/−0
• Duckling/Time/EN/Corpus.hs +228/−103
• Duckling/Time/EN/GB/Corpus.hs +60/−0
• Duckling/Time/EN/GB/Rules.hs +70/−0
• Duckling/Time/EN/Rules.hs +108/−66
• Duckling/Time/EN/US/Corpus.hs +60/−0
• Duckling/Time/EN/US/Rules.hs +70/−0
• Duckling/Time/ES/Corpus.hs +5/−4
• Duckling/Time/ES/Rules.hs +70/−217
• Duckling/Time/FR/Corpus.hs +13/−3
• Duckling/Time/FR/Rules.hs +136/−282
• Duckling/Time/GA/Corpus.hs +5/−4
• Duckling/Time/GA/Rules.hs +65/−207
• Duckling/Time/HE/Corpus.hs +5/−4
• Duckling/Time/HE/Rules.hs +118/−215
• Duckling/Time/HR/Corpus.hs +6/−5
• Duckling/Time/HR/Rules.hs +90/−236
• Duckling/Time/HU/Corpus.hs +176/−0
• Duckling/Time/HU/Rules.hs +325/−0
• Duckling/Time/Helpers.hs +45/−29
• Duckling/Time/IT/Corpus.hs +19/−5
• Duckling/Time/IT/Rules.hs +60/−205
• Duckling/Time/KO/Corpus.hs +5/−4
• Duckling/Time/KO/Rules.hs +111/−115
• Duckling/Time/NB/Corpus.hs +6/−6
• Duckling/Time/NB/Rules.hs +75/−221
• Duckling/Time/PL/Corpus.hs +32/−7
• Duckling/Time/PL/Rules.hs +118/−281
• Duckling/Time/PT/Corpus.hs +10/−6
• Duckling/Time/PT/Rules.hs +42/−47
• Duckling/Time/RO/Corpus.hs +13/−5
• Duckling/Time/RO/Rules.hs +97/−243
• Duckling/Time/SV/Corpus.hs +23/−21
• Duckling/Time/SV/Rules.hs +99/−232
• Duckling/Time/VI/Corpus.hs +6/−5
• Duckling/Time/VI/Rules.hs +110/−256
• Duckling/Time/ZH/CN/Corpus.hs +37/−0
• Duckling/Time/ZH/CN/Rules.hs +35/−0
• Duckling/Time/ZH/Corpus.hs +12/−14
• Duckling/Time/ZH/HK/Corpus.hs +37/−0
• Duckling/Time/ZH/HK/Rules.hs +35/−0
• Duckling/Time/ZH/MO/Corpus.hs +37/−0
• Duckling/Time/ZH/MO/Rules.hs +35/−0
• Duckling/Time/ZH/Rules.hs +131/−285
• Duckling/Time/ZH/TW/Corpus.hs +37/−0
• Duckling/Time/ZH/TW/Rules.hs +35/−0
• Duckling/TimeGrain/DA/Rules.hs +2/−2
• Duckling/TimeGrain/ES/Rules.hs +2/−2
• Duckling/TimeGrain/FR/Rules.hs +2/−2
• Duckling/TimeGrain/GA/Rules.hs +6/−6
• Duckling/TimeGrain/HE/Rules.hs +8/−8
• Duckling/TimeGrain/HR/Rules.hs +1/−1
• Duckling/TimeGrain/HU/Rules.hs +40/−0
• Duckling/TimeGrain/JA/Rules.hs +7/−7
• Duckling/TimeGrain/KO/Rules.hs +8/−8
• Duckling/TimeGrain/NB/Rules.hs +2/−2
• Duckling/TimeGrain/NL/Rules.hs +40/−0
• Duckling/TimeGrain/PL/Rules.hs +7/−7
• Duckling/TimeGrain/PT/Rules.hs +2/−2
• Duckling/TimeGrain/RO/Rules.hs +5/−5
• Duckling/TimeGrain/SV/Rules.hs +2/−2
• Duckling/TimeGrain/TR/Rules.hs +1/−1
• Duckling/TimeGrain/Types.hs +16/−5
• Duckling/TimeGrain/VI/Rules.hs +8/−8
• Duckling/TimeGrain/ZH/Rules.hs +7/−7
• Duckling/Types.hs +1/−1
• Duckling/Types/Document.hs +5/−6
• Duckling/Volume/ES/Corpus.hs +2/−2
• Duckling/Volume/ES/Rules.hs +1/−1
• Duckling/Volume/FR/Corpus.hs +2/−2
• Duckling/Volume/GA/Corpus.hs +2/−2
• Duckling/Volume/GA/Rules.hs +5/−5
• Duckling/Volume/HR/Corpus.hs +2/−2
• Duckling/Volume/IT/Corpus.hs too large to diff
• Duckling/Volume/KO/Corpus.hs too large to diff
• Duckling/Volume/KO/Rules.hs too large to diff
• Duckling/Volume/NL/Corpus.hs too large to diff
• Duckling/Volume/PT/Corpus.hs too large to diff
• Duckling/Volume/PT/Rules.hs too large to diff
• Duckling/Volume/RO/Corpus.hs too large to diff
• Duckling/Volume/RO/Rules.hs too large to diff
• Duckling/Volume/TR/Corpus.hs too large to diff
• README.md too large to diff
• duckling.cabal too large to diff
• exe/Duckling/Ranking/Generate.hs too large to diff
• exe/Duckling/Ranking/Train.hs too large to diff
• exe/DucklingExpensive.hs too large to diff
• exe/DucklingRequestSample.hs too large to diff
• exe/ExampleMain.hs too large to diff
• tests/Duckling/AmountOfMoney/BG/Tests.hs too large to diff
• tests/Duckling/AmountOfMoney/Tests.hs too large to diff
• tests/Duckling/Api/Tests.hs too large to diff
• tests/Duckling/Duration/HU/Tests.hs too large to diff
• tests/Duckling/Duration/NL/Tests.hs too large to diff
• tests/Duckling/Duration/Tests.hs too large to diff
• tests/Duckling/Duration/ZH/Tests.hs too large to diff
• tests/Duckling/Email/EN/Tests.hs too large to diff
• tests/Duckling/Numeral/BG/Tests.hs too large to diff
• tests/Duckling/Numeral/HU/Tests.hs too large to diff
• tests/Duckling/Numeral/KA/Tests.hs too large to diff
• tests/Duckling/Numeral/Tests.hs too large to diff
• tests/Duckling/Ordinal/ES/Tests.hs too large to diff
• tests/Duckling/Ordinal/HU/Tests.hs too large to diff
• tests/Duckling/Ordinal/Tests.hs too large to diff
• tests/Duckling/Testing/Asserts.hs too large to diff
• tests/Duckling/Time/DA/Tests.hs too large to diff
• tests/Duckling/Time/EN/Tests.hs too large to diff
• tests/Duckling/Time/ES/Tests.hs too large to diff
• tests/Duckling/Time/FR/Tests.hs too large to diff
• tests/Duckling/Time/GA/Tests.hs too large to diff
• tests/Duckling/Time/HU/Tests.hs too large to diff
• tests/Duckling/Time/IT/Tests.hs too large to diff
• tests/Duckling/Time/KO/Tests.hs too large to diff
• tests/Duckling/Time/NB/Tests.hs too large to diff
• tests/Duckling/Time/PL/Tests.hs too large to diff
• tests/Duckling/Time/PT/Tests.hs too large to diff
• tests/Duckling/Time/RO/Tests.hs too large to diff
• tests/Duckling/Time/SV/Tests.hs too large to diff
• tests/Duckling/Time/Tests.hs too large to diff
• tests/Duckling/Time/VI/Tests.hs too large to diff
• tests/Duckling/Time/ZH/Tests.hs too large to diff

@@ -0,0 +1,120 @@+-- Copyright (c) 2016-present, Facebook, Inc.+-- All rights reserved.+--+-- This source code is licensed under the BSD-style license found in the+-- LICENSE file in the root directory of this source tree. An additional grant+-- of patent rights can be found in the PATENTS file in the same directory.++{-# LANGUAGE OverloadedStrings #-}++module Duckling.AmountOfMoney.BG.Corpus+  ( corpus+  ) where++import Data.String+import Prelude++import Duckling.AmountOfMoney.Types+import Duckling.Locale+import Duckling.Resolve+import Duckling.Testing.Types++corpus :: Corpus+corpus = (testContext {locale = makeLocale BG Nothing}, allExamples)++allExamples :: [Example]+allExamples = concat+  [ examples (simple BGN 1)+             [ "1 лв"+             , "един лев"+             , "1 Лев"+             ]+  , examples (simple BGN 10)+             [ "10 лв"+             , "десет лева"+             , "10лв"+             ]+  , examples (simple BGN 15.50)+             [ "15лв и 50ст"+             , "петнадесет лева и петдесет стотинки"+             , "15 Лв и 50 Ст"+             ]+  , examples (simple Dollar 1)+             [ "$1"+             , "един долар"+             , "1 долар"+             ]+  , examples (simple Dollar 10)+             [ "$10"+             , "$ 10"+             , "10$"+             , "10 Долара"+             , "десет долара"+             ]+  , examples (simple Cent 10)+             [ "10 цента"+             , "десет пенита"+             , "десет цента"+             , "10¢"+             ]+  , examples (simple Cent 50)+             [ "50 ст"+             , "петдесет стотинки"+             , "50ст"+             ]+  , examples (simple Dollar 1e4)+             [ "$10К"+             , "10к$"+             , "$10,000"+             ]+  , examples (simple USD 3.14)+             [ "USD3.14"+             , "3.14US$"+             , "US$ 3.14"+             ]+  , examples (simple EUR 20)+             [ "20\x20ac"+             , "20 евро"+             , "20 Евро"+             , "EUR 20"+             , "EUR 20.0"+             , "20€"+             , "20 €ur"+             ]+  , examples (simple Pound 10)+             [ "\x00a3\&10"+             , "десет паунда"+             ]+  , examples (simple Dollar 20.43)+             [ "$20 и 43ц"+             , "$20 43"+             , "20 долара 43ц"+             , "20 долара 43 цента"+             , "двадесет долара 43 цента"+             , "20 долара 43"+             , "двадесет долара и 43"+             ]+  , examples (simple GBP 3.01)+             [ "GBP3.01"+             , "GBP 3.01"+             , "3 GBP 1 пени"+             ]+  , examples (between Dollar (10, 20))+             [ "между 10 и 20 долара"+             , "от 10 до 20 долара"+             , "около 10-20 долара"+             , "между 10 и 20 долара"+             , "около $10-$20"+             , "10-20 долара"+             ]+  , examples (under EUR 7)+             [ "под седем евро"+             , "по-малко от 7 Евро"+             , "под 7€"+             ]+  , examples (above Dollar 1.42)+             [ "над 1 долар и четиридесет и два цента"+             , "поне $1.42"+             , "над 1.42 долара"+             ]+  ]

@@ -0,0 +1,267 @@+-- Copyright (c) 2016-present, Facebook, Inc.+-- All rights reserved.+--+-- This source code is licensed under the BSD-style license found in the+-- LICENSE file in the root directory of this source tree. An additional grant+-- of patent rights can be found in the PATENTS file in the same directory.+++{-# LANGUAGE GADTs #-}+{-# LANGUAGE OverloadedStrings #-}++module Duckling.AmountOfMoney.BG.Rules+  ( rules+  ) where++import Data.Maybe+import Data.String+import Prelude+import qualified Data.Text as Text++import Duckling.AmountOfMoney.Helpers+import Duckling.AmountOfMoney.Types (Currency(..), AmountOfMoneyData (..))+import Duckling.Dimensions.Types+import Duckling.Numeral.Types (NumeralData (..))+import Duckling.Regex.Types+import Duckling.Types+import qualified Duckling.AmountOfMoney.Types as TAmountOfMoney+import qualified Duckling.Numeral.Types as TNumeral++ruleBGN :: Rule+ruleBGN = Rule+  { name = "лв"+  , pattern =+    [ regex "ле?ва?"+    ]+  , prod = \_ -> Just . Token AmountOfMoney $ currencyOnly BGN+  }++rulePounds :: Rule+rulePounds = Rule+  { name = "£"+  , pattern =+    [ regex "паунд(а|и)?"+    ]+  , prod = \_ -> Just . Token AmountOfMoney $ currencyOnly Pound+  }++ruleDollar :: Rule+ruleDollar = Rule+  { name = "$"+  , pattern =+    [ regex "долар(а|и)?"+    ]+  , prod = \_ -> Just . Token AmountOfMoney $ currencyOnly Dollar+  }++ruleCent :: Rule+ruleCent = Rule+  { name = "cent"+  , pattern =+    [ regex "ст(отинк(a|и))?|цента?|пени(та)?|пенса?|ц"+    ]+  , prod = \_ -> Just . Token AmountOfMoney $ currencyOnly Cent+  }++ruleEUR :: Rule+ruleEUR = Rule+  { name = "€"+  , pattern =+    [ regex "евр(о|а)"+    ]+  , prod = \_ -> Just . Token AmountOfMoney $ currencyOnly EUR+  }++ruleIntersectAndXCents :: Rule+ruleIntersectAndXCents = Rule+  { name = "intersect (and X cents)"+  , pattern =+    [ financeWith TAmountOfMoney.value isJust+    , regex "и"+    , financeWith TAmountOfMoney.currency (== Cent)+    ]+  , prod = \tokens -> case tokens of+      (Token AmountOfMoney fd:+       _:+       Token AmountOfMoney (AmountOfMoneyData {TAmountOfMoney.value = Just c}):+       _) -> Just . Token AmountOfMoney $ withCents c fd+      _ -> Nothing+  }++ruleIntersect :: Rule+ruleIntersect = Rule+  { name = "intersect"+  , pattern =+    [ financeWith TAmountOfMoney.value isJust+    , dimension Numeral+    ]+  , prod = \tokens -> case tokens of+      (Token AmountOfMoney fd:+       Token Numeral (NumeralData {TNumeral.value = c}):+       _) -> Just . Token AmountOfMoney $ withCents c fd+      _ -> Nothing+  }++ruleIntersectAndNumeral :: Rule+ruleIntersectAndNumeral = Rule+  { name = "intersect (and number)"+  , pattern =+    [ financeWith TAmountOfMoney.value isJust+    , regex "и"+    , dimension Numeral+    ]+  , prod = \tokens -> case tokens of+      (Token AmountOfMoney fd:+       _:+       Token Numeral (NumeralData {TNumeral.value = c}):+       _) -> Just . Token AmountOfMoney $ withCents c fd+      _ -> Nothing+  }++ruleIntersectXCents :: Rule+ruleIntersectXCents = Rule+  { name = "intersect (X cents)"+  , pattern =+    [ financeWith TAmountOfMoney.value isJust+    , financeWith id $ \x -> case TAmountOfMoney.value x of+        Just v | v > 0 -> TAmountOfMoney.currency x == Cent+        _              -> False+    ]+  , prod = \tokens -> case tokens of+      (Token AmountOfMoney fd:+       Token AmountOfMoney (AmountOfMoneyData {TAmountOfMoney.value = Just c}):+       _) -> Just . Token AmountOfMoney $ withCents c fd+      _ -> Nothing+  }++rulePrecision :: Rule+rulePrecision = Rule+  { name = "about|exactly <amount-of-money>"+  , pattern =+    [ regex "точно|около|приблизително|близо (до)?|почти"+    , dimension AmountOfMoney+    ]+  , prod = \tokens -> case tokens of+      (_:token:_) -> Just token+      _ -> Nothing+  }++ruleIntervalBetweenNumeral :: Rule+ruleIntervalBetweenNumeral = Rule+  { name = "between|from <numeral> to|and <amount-of-money>"+  , pattern =+    [ regex "между|от"+    , dimension Numeral+    , regex "до|и"+    , financeWith TAmountOfMoney.value isJust+    ]+  , prod = \tokens -> case tokens of+      (_:+       Token Numeral (NumeralData {TNumeral.value = from}):+       _:+       Token AmountOfMoney (AmountOfMoneyData {TAmountOfMoney.value = Just to, TAmountOfMoney.currency = c}):+       _) ->+        Just . Token AmountOfMoney . withInterval (from, to) $ currencyOnly c+      _ -> Nothing+  }++ruleIntervalBetween :: Rule+ruleIntervalBetween = Rule+  { name = "between|from <amount-of-money> to|and <amount-of-money>"+  , pattern =+    [ regex "между|от"+    , financeWith TAmountOfMoney.value isJust+    , regex "до|и"+    , financeWith TAmountOfMoney.value isJust+    ]+  , prod = \tokens -> case tokens of+      (_:+       Token AmountOfMoney (AmountOfMoneyData {TAmountOfMoney.value = Just from, TAmountOfMoney.currency = c1}):+       _:+       Token AmountOfMoney (AmountOfMoneyData {TAmountOfMoney.value = Just to, TAmountOfMoney.currency = c2}):+       _) | c1 == c2 ->+        Just . Token AmountOfMoney . withInterval (from, to) $ currencyOnly c1+      _ -> Nothing+  }++ruleIntervalNumeralDash :: Rule+ruleIntervalNumeralDash = Rule+  { name = "<numeral> - <amount-of-money>"+  , pattern =+    [ dimension Numeral+    , regex "-"+    , financeWith TAmountOfMoney.value isJust+    ]+  , prod = \tokens -> case tokens of+      (Token Numeral (NumeralData {TNumeral.value = from}):+       _:+       Token AmountOfMoney (AmountOfMoneyData {TAmountOfMoney.value = Just to, TAmountOfMoney.currency = c}):+       _) ->+         Just . Token AmountOfMoney . withInterval (from, to) $ currencyOnly c+      _ -> Nothing+  }++ruleIntervalDash :: Rule+ruleIntervalDash = Rule+  { name = "<amount-of-money> - <amount-of-money>"+  , pattern =+    [ financeWith TAmountOfMoney.value isJust+    , regex "-"+    , financeWith TAmountOfMoney.value isJust+    ]+  , prod = \tokens -> case tokens of+      (Token AmountOfMoney (AmountOfMoneyData {TAmountOfMoney.value = Just from, TAmountOfMoney.currency = c1}):+       _:+       Token AmountOfMoney (AmountOfMoneyData {TAmountOfMoney.value = Just to, TAmountOfMoney.currency = c2}):+       _) | c1 == c2 ->+        Just . Token AmountOfMoney . withInterval (from, to) $ currencyOnly c1+      _ -> Nothing+  }++ruleIntervalMax :: Rule+ruleIntervalMax = Rule+  { name = "under/less/lower/no more than <amount-of-money>"+  , pattern =+    [ regex "под|по-малко от|не повече от"+    , financeWith TAmountOfMoney.value isJust+    ]+  , prod = \tokens -> case tokens of+      (_:+       Token AmountOfMoney (AmountOfMoneyData {TAmountOfMoney.value = Just to, TAmountOfMoney.currency = c}):+       _) -> Just . Token AmountOfMoney . withMax to $ currencyOnly c+      _ -> Nothing+  }++ruleIntervalMin :: Rule+ruleIntervalMin = Rule+  { name = "over/above/at least/more than <amount-of-money>"+  , pattern =+    [ regex "над|поне|повече от"+    , financeWith TAmountOfMoney.value isJust+    ]+  , prod = \tokens -> case tokens of+      (_:+       Token AmountOfMoney (AmountOfMoneyData {TAmountOfMoney.value = Just to, TAmountOfMoney.currency = c}):+       _) -> Just . Token AmountOfMoney . withMin to $ currencyOnly c+      _ -> Nothing+  }++rules :: [Rule]+rules =+  [ ruleBGN+  , ruleDollar+  , ruleCent+  , ruleEUR+  , ruleIntersect+  , ruleIntersectAndNumeral+  , ruleIntersectAndXCents+  , ruleIntersectXCents+  , ruleIntervalBetweenNumeral+  , ruleIntervalBetween+  , ruleIntervalMax+  , ruleIntervalMin+  , ruleIntervalNumeralDash+  , ruleIntervalDash+  , rulePounds+  , rulePrecision+  ]

@@ -9,10 +9,11 @@ {-# LANGUAGE OverloadedStrings #-}  module Duckling.AmountOfMoney.EN.Corpus-  ( corpus ) where+  ( corpus+  ) where -import Prelude import Data.String+import Prelude  import Duckling.AmountOfMoney.Types import Duckling.Testing.Types@@ -114,6 +115,9 @@   , examples (simple SAR 42)              [ "42 SAR"              , "42 Saudiriyal"+             ]+  , examples (simple BGN 42)+             [ "42 BGN"              ]   , examples (simple MYR 42)              [ "42 MYR"

@@ -9,18 +9,19 @@ {-# LANGUAGE OverloadedStrings #-}  module Duckling.AmountOfMoney.ES.Corpus-  ( corpus ) where+  ( corpus+  ) where -import Prelude import Data.String+import Prelude  import Duckling.AmountOfMoney.Types-import Duckling.Lang+import Duckling.Locale import Duckling.Resolve import Duckling.Testing.Types  corpus :: Corpus-corpus = (testContext {lang = ES}, allExamples)+corpus = (testContext {locale = makeLocale ES Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -28,7 +28,7 @@ ruleDollar = Rule   { name = "dollar"   , pattern =-    [ regex "d(\x00f3|o)lar(es)?"+    [ regex "d(ó|o)lar(es)?"     ]   , prod = \_ -> Just . Token AmountOfMoney $ currencyOnly Dollar   }

@@ -9,18 +9,19 @@ {-# LANGUAGE OverloadedStrings #-}  module Duckling.AmountOfMoney.FR.Corpus-  ( corpus ) where+  ( corpus+  ) where -import Prelude import Data.String+import Prelude  import Duckling.AmountOfMoney.Types-import Duckling.Lang+import Duckling.Locale import Duckling.Resolve import Duckling.Testing.Types  corpus :: Corpus-corpus = (testContext {lang = FR}, allExamples)+corpus = (testContext {locale = makeLocale FR Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -44,7 +44,7 @@ rulePrecision = Rule   { name = "precision"   , pattern =-    [ regex "exactement|quasi|plus ou moins|environ|autour de|(a|\x00e0) peu pr(e|\x00e8)s"+    [ regex "exactement|quasi|plus ou moins|environ|autour de|(a|à) peu pr(e|è)s"     , financeWith TAmountOfMoney.value isJust     ]   , prod = \tokens -> case tokens of

@@ -9,18 +9,19 @@ {-# LANGUAGE OverloadedStrings #-}  module Duckling.AmountOfMoney.GA.Corpus-  ( corpus ) where+  ( corpus+  ) where -import Prelude import Data.String+import Prelude  import Duckling.AmountOfMoney.Types-import Duckling.Lang+import Duckling.Locale import Duckling.Resolve import Duckling.Testing.Types  corpus :: Corpus-corpus = (testContext {lang = GA}, allExamples)+corpus = (testContext {locale = makeLocale GA Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -111,7 +111,7 @@ ruleInr = Rule   { name = "INR"   , pattern =-    [ regex "r(\x00fa|u)pa(\x00ed|i)"+    [ regex "r(ú|u)pa(í|i)"     ]   , prod = \_ -> Just . Token AmountOfMoney $ currencyOnly INR   }@@ -137,7 +137,7 @@   { name = "<amount-of-money> glan"   , pattern =     [ financeWith TAmountOfMoney.value isJust-    , regex "glan|baileach|(go )?d(\x00ed|i)reach"+    , regex "glan|baileach|(go )?d(í|i)reach"     ]   , prod = \tokens -> case tokens of       (token:_) -> Just token

@@ -8,18 +8,19 @@ {-# LANGUAGE OverloadedStrings #-}  module Duckling.AmountOfMoney.HR.Corpus-  ( corpus ) where+  ( corpus+  ) where -import Prelude import Data.String+import Prelude -import Duckling.Lang import Duckling.AmountOfMoney.Types+import Duckling.Locale import Duckling.Resolve import Duckling.Testing.Types  corpus :: Corpus-corpus = (testContext {lang = HR}, allExamples)+corpus = (testContext {locale = makeLocale HR Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -64,7 +64,7 @@ ruleCent = Rule   { name = "cent"   , pattern =-    [ regex "cent(i|a)?|penij(i|a)?|c|\x00a2|lp|lip(a|e)"+    [ regex "cent(i|a)?|penij(i|a)?|c|¢|lp|lip(a|e)"     ]   , prod = \_ -> Just . Token AmountOfMoney $ currencyOnly Cent   }

@@ -9,18 +9,19 @@ {-# LANGUAGE OverloadedStrings #-}  module Duckling.AmountOfMoney.ID.Corpus-  ( corpus ) where+  ( corpus+  ) where -import Prelude import Data.String+import Prelude  import Duckling.AmountOfMoney.Types-import Duckling.Lang+import Duckling.Locale import Duckling.Resolve import Duckling.Testing.Types  corpus :: Corpus-corpus = (testContext {lang = ID}, allExamples)+corpus = (testContext {locale = makeLocale ID Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -69,7 +69,7 @@ ruleJpy = Rule   { name = "JPY"   , pattern =-    [ regex "\x00a5\\."+    [ regex "¥\\."     ]   , prod = \_ -> Just . Token AmountOfMoney $ currencyOnly JPY   }

@@ -9,18 +9,19 @@ {-# LANGUAGE OverloadedStrings #-}  module Duckling.AmountOfMoney.KO.Corpus-  ( corpus ) where+  ( corpus+  ) where -import Prelude import Data.String+import Prelude  import Duckling.AmountOfMoney.Types-import Duckling.Lang+import Duckling.Locale import Duckling.Resolve import Duckling.Testing.Types  corpus :: Corpus-corpus = (testContext {lang = KO}, allExamples)+corpus = (testContext {locale = makeLocale KO Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -27,7 +27,7 @@   { name = "<amount-of-money> about"   , pattern =     [ financeWith TAmountOfMoney.value isJust-    , regex "\xc815\xb3c4|\xcbe4"+    , regex "정도|쯤"     ]   , prod = \tokens -> case tokens of       (token:_) -> Just token@@ -38,7 +38,7 @@ ruleAud = Rule   { name = "AUD"   , pattern =-    [ regex "\xd638\xc8fc\xb2ec\xb7ec"+    [ regex "호주달러"     ]   , prod = \_ -> Just . Token AmountOfMoney $ currencyOnly AUD   }@@ -47,7 +47,7 @@ ruleKrw = Rule   { name = "₩"   , pattern =-    [ regex "\x20a9|\xc6d0"+    [ regex "₩|원"     ]   , prod = \_ -> Just . Token AmountOfMoney $ currencyOnly KRW   }@@ -56,7 +56,7 @@ ruleAboutAmountofmoney = Rule   { name = "about <amount-of-money>"   , pattern =-    [ regex "\xc57d|\xb300\xcda9|\xc5bc\xcd94"+    [ regex "약|대충|얼추"     , financeWith TAmountOfMoney.value isJust     ]   , prod = \tokens -> case tokens of@@ -68,7 +68,7 @@ ruleCent = Rule   { name = "cent"   , pattern =-    [ regex "cents?|\xc13c(\xd2b8|\xce20)"+    [ regex "cents?|센(트|츠)"     ]   , prod = \_ -> Just . Token AmountOfMoney $ currencyOnly Cent   }@@ -77,7 +77,7 @@ ruleExactlyAmountofmoney = Rule   { name = "exactly <amount-of-money>"   , pattern =-    [ regex "\xb531|\xc815\xd655\xd788"+    [ regex "딱|정확히"     , financeWith TAmountOfMoney.value isJust     ]   , prod = \tokens -> case tokens of@@ -103,7 +103,7 @@ ruleEuro = Rule   { name = "€"   , pattern =-    [ regex "\x20ac|\xc720\xb85c"+    [ regex "€|유로"     ]   , prod = \_ -> Just . Token AmountOfMoney $ currencyOnly EUR   }@@ -112,7 +112,7 @@ ruleDollar = Rule   { name = "$"   , pattern =-    [ regex "\xb2ec\xb7ec|\xbd88"+    [ regex "달러|불"     ]   , prod = \_ -> Just . Token AmountOfMoney $ currencyOnly Dollar   }@@ -121,7 +121,7 @@ ruleInr = Rule   { name = "INR"   , pattern =-    [ regex "\xb8e8\xd53c|\xc778\xb3c4\xb8e8\xd53c"+    [ regex "루피|인도루피"     ]   , prod = \_ -> Just . Token AmountOfMoney $ currencyOnly INR   }@@ -130,7 +130,7 @@ rulePounds = Rule   { name = "£"   , pattern =-    [ regex "\xd30c\xc6b4\xb4dc|\xc601\xad6d\xd30c\xc6b4\xb4dc"+    [ regex "파운드|영국파운드"     ]   , prod = \_ -> Just . Token AmountOfMoney $ currencyOnly Pound   }

@@ -9,18 +9,19 @@ {-# LANGUAGE OverloadedStrings #-}  module Duckling.AmountOfMoney.NB.Corpus-  ( corpus ) where+  ( corpus+  ) where -import Prelude import Data.String+import Prelude  import Duckling.AmountOfMoney.Types-import Duckling.Lang+import Duckling.Locale import Duckling.Resolve import Duckling.Testing.Types  corpus :: Corpus-corpus = (testContext {lang = NB}, allExamples)+corpus = (testContext {locale = makeLocale NB Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -56,7 +56,7 @@ ruleCent = Rule   { name = "cent"   , pattern =-    [ regex "cents?|penn(y|ies)|(\x00f8)re"+    [ regex "cents?|penn(y|ies)|(ø)re"     ]   , prod = \_ -> Just . Token AmountOfMoney $ currencyOnly Cent   }

@@ -9,18 +9,19 @@ {-# LANGUAGE OverloadedStrings #-}  module Duckling.AmountOfMoney.PT.Corpus-  ( corpus ) where+  ( corpus+  ) where -import Prelude import Data.String+import Prelude  import Duckling.AmountOfMoney.Types-import Duckling.Lang+import Duckling.Locale import Duckling.Resolve import Duckling.Testing.Types  corpus :: Corpus-corpus = (testContext {lang = PT}, allExamples)+corpus = (testContext {locale = makeLocale PT Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -9,18 +9,19 @@ {-# LANGUAGE OverloadedStrings #-}  module Duckling.AmountOfMoney.RO.Corpus-  ( corpus ) where+  ( corpus+  ) where -import Prelude import Data.String+import Prelude  import Duckling.AmountOfMoney.Types-import Duckling.Lang+import Duckling.Locale import Duckling.Resolve import Duckling.Testing.Types  corpus :: Corpus-corpus = (testContext {lang = RO}, allExamples)+corpus = (testContext {locale = makeLocale RO Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -31,7 +31,7 @@   { name = "intersect (and number)"   , pattern =     [ financeWith TAmountOfMoney.value isJust-    , regex "(s|\x0219)i"+    , regex "(s|ș)i"     , dimension Numeral     ]   , prod = \tokens -> case tokens of@@ -71,7 +71,7 @@ rulePrecisionAmountofmoney = Rule   { name = "about/exactly <amount-of-money>"   , pattern =-    [ regex "exact|cam|aprox(\\.|imativ)?|aproape|(i|\x00ee)n jur (de)?"+    [ regex "exact|cam|aprox(\\.|imativ)?|aproape|(i|î)n jur (de)?"     , financeWith TAmountOfMoney.value isJust     ]   , prod = \tokens -> case tokens of@@ -83,7 +83,7 @@ ruleCent = Rule   { name = "cent|bani"   , pattern =-    [ regex "bani?|cen(t|\x021b)i?|c|\x00a2"+    [ regex "bani?|cen(t|ț)i?|c|¢"     ]   , prod = \_ -> Just . Token AmountOfMoney $ currencyOnly Cent   }@@ -102,7 +102,7 @@   { name = "intersect (and X cents)"   , pattern =     [ financeWith TAmountOfMoney.value isJust-    , regex "(s|\x0219)i"+    , regex "(s|ș)i"     , financeWith TAmountOfMoney.currency (== Cent)     ]   , prod = \tokens -> case tokens of@@ -140,7 +140,7 @@ ruleOtherPounds = Rule   { name = "other pounds"   , pattern =-    [ regex "lir(a|\x0103) (egiptian|libanez)(a|\x0103)"+    [ regex "lir(a|ă) (egiptian|libanez)(a|ă)"     ]   , prod = \tokens -> case tokens of       (Token RegexMatch (GroupMatch (_:match:_)):_) -> case Text.toLower match of

@@ -34,22 +34,23 @@ currencies = HashMap.fromList   [ ("aed", AED)   , ("aud", AUD)+  , ("bgn", BGN)   , ("brl", BRL)-  , ("\x00a2", Cent)+  , ("¢", Cent)   , ("c", Cent)   , ("$", Dollar)   , ("dollar", Dollar)   , ("dollars", Dollar)   , ("egp", EGP)-  , ("\x20ac", EUR)+  , ("€", EUR)   , ("eur", EUR)   , ("euro", EUR)   , ("euros", EUR)   , ("eurs", EUR)-  , ("\x20acur", EUR)-  , ("\x20acuro", EUR)-  , ("\x20acuros", EUR)-  , ("\x20acurs", EUR)+  , ("€ur", EUR)+  , ("€uro", EUR)+  , ("€uros", EUR)+  , ("€urs", EUR)   , ("gbp", GBP)   , ("hrk", HRK)   , ("idr", IDR)@@ -58,7 +59,7 @@   , ("rs.", INR)   , ("rupee", INR)   , ("rupees", INR)-  , ("\x00a5", JPY)+  , ("¥", JPY)   , ("jpy", JPY)   , ("yen", JPY)   , ("krw", KRW)@@ -67,7 +68,7 @@   , ("myr", MYR)   , ("rm", MYR)   , ("nok", NOK)-  , ("\x00a3", Pound)+  , ("£", Pound)   , ("pt", PTS)   , ("pta", PTS)   , ("ptas", PTS)@@ -86,7 +87,7 @@ ruleCurrencies = Rule   { name = "currencies"   , pattern =-    [ regex "(aed|aud|brl|\x00a2|c|\\$|dollars?|egp|(e|\x20ac)uro?s?|\x20ac|gbp|hrk|idr|inr|\x00a5|jpy|krw|kwd|lbp|myr|rm|nok|\x00a3|pta?s?|qar|rs\\.?|ron|rupees?|sar|sek|sgb|us(d|\\$)|vnd|yen)"+    [ regex "(aed|aud|bgn|brl|¢|c|\\$|dollars?|egp|(e|€)uro?s?|€|gbp|hrk|idr|inr|¥|jpy|krw|kwd|lbp|myr|rm|nok|£|pta?s?|qar|rs\\.?|ron|rupees?|sar|sek|sgb|us(d|\\$)|vnd|yen)"     ]   , prod = \tokens -> case tokens of       (Token RegexMatch (GroupMatch (match:_)):_) -> do

@@ -9,18 +9,19 @@ {-# LANGUAGE OverloadedStrings #-}  module Duckling.AmountOfMoney.SV.Corpus-  ( corpus ) where+  ( corpus+  ) where -import Prelude import Data.String+import Prelude  import Duckling.AmountOfMoney.Types-import Duckling.Lang+import Duckling.Locale import Duckling.Resolve import Duckling.Testing.Types  corpus :: Corpus-corpus = (testContext {lang = SV}, allExamples)+corpus = (testContext {locale = makeLocale SV Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -56,7 +56,7 @@ ruleCent = Rule   { name = "cent"   , pattern =-    [ regex "cents?|penn(y|ies)|\x00f6re"+    [ regex "cents?|penn(y|ies)|öre"     ]   , prod = \_ -> Just . Token AmountOfMoney $ currencyOnly Cent   }

@@ -34,6 +34,7 @@   -- unambiguous   | AED   | AUD+  | BGN   | BRL   | EGP   | EUR@@ -64,6 +65,7 @@   toJSON Unnamed = "unknown"   toJSON AED     = "AED"   toJSON AUD     = "AUD"+  toJSON BGN     = "BGN"   toJSON BRL     = "BRL"   toJSON EGP     = "EGP"   toJSON EUR     = "EUR"

@@ -9,18 +9,19 @@ {-# LANGUAGE OverloadedStrings #-}  module Duckling.AmountOfMoney.VI.Corpus-  ( corpus ) where+  ( corpus+  ) where -import Prelude import Data.String+import Prelude  import Duckling.AmountOfMoney.Types-import Duckling.Lang+import Duckling.Locale import Duckling.Resolve import Duckling.Testing.Types  corpus :: Corpus-corpus = (testContext {lang = VI}, allExamples)+corpus = (testContext {locale = makeLocale VI Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -28,7 +28,7 @@ ruleNg = Rule   { name = "đồng"   , pattern =-    [ regex "\x0111\x1ed3ng?"+    [ regex "đồng?"     ]   , prod = \_ -> Just . Token AmountOfMoney $ currencyOnly VND   }@@ -37,7 +37,7 @@ ruleDollar = Rule   { name = "$"   , pattern =-    [ regex "\x0111\x00f4 la|\x0111\x00f4 m\x1ef9|\x0111(\x00f4)?"+    [ regex "đô la|đô mỹ|đ(ô)?"     ]   , prod = \_ -> Just . Token AmountOfMoney $ currencyOnly Dollar   }@@ -46,7 +46,7 @@ ruleVnd = Rule   { name = "VNĐ"   , pattern =-    [ regex "vn(\x0110|\\$)"+    [ regex "vn(Đ|\\$)"     ]   , prod = \_ -> Just . Token AmountOfMoney $ currencyOnly VND   }@@ -88,7 +88,7 @@   { name = "intersect and number"   , pattern =     [ financeWith TAmountOfMoney.value isJust-    , regex "v\x00e0"+    , regex "và"     , dimension Numeral     ]   , prod = \tokens -> case tokens of@@ -118,7 +118,7 @@   { name = "intersect (và X xu|xen)"   , pattern =     [ financeWith TAmountOfMoney.value isJust-    , regex "v\x00e0"+    , regex "và"     , financeWith TAmountOfMoney.currency (== Cent)     ]   , prod = \tokens -> case tokens of

@@ -17,18 +17,18 @@   ) where  import Data.HashMap.Strict (HashMap)-import qualified Data.HashMap.Strict as HashMap import Data.HashSet (HashSet)-import qualified Data.HashSet as HashSet import Data.Text (Text)-import qualified Data.Text as Text import Prelude import TextShow+import qualified Data.HashMap.Strict as HashMap+import qualified Data.HashSet as HashSet+import qualified Data.Text as Text  import Duckling.Dimensions.Types import Duckling.Dimensions import Duckling.Engine-import Duckling.Lang+import Duckling.Locale import Duckling.Ranking.Classifiers import Duckling.Ranking.Rank import Duckling.Resolve@@ -47,11 +47,11 @@ -- When `targets` is non-empty, returns only tokens of such dimensions. analyze :: Text -> Context -> HashSet (Some Dimension) -> [ResolvedToken] analyze input context@Context{..} targets =-  rank (classifiers lang) targets+  rank (classifiers locale) targets   . filter (\(Resolved{node = Node{token = (Token d _)}}) ->       HashSet.null targets || HashSet.member (This d) targets     )-  $ parseAndResolve (rulesFor lang targets) input context+  $ parseAndResolve (rulesFor locale targets) input context  -- | Converts the resolved token to the API format formatToken :: Text -> ResolvedToken -> Entity

@@ -12,16 +12,20 @@  module Duckling.Core   ( Context(..)+  , Region(..)   , Dimension(..)-  , fromName   , Entity(..)   , Lang(..)+  , Locale   , Some(..)+  , fromName+  , makeLocale   , toName    -- Duckling API   , parse   , supportedDimensions+  , allLocales    -- Reference time builders   , currentReftime@@ -39,7 +43,7 @@  import Duckling.Api import Duckling.Dimensions.Types-import Duckling.Lang+import Duckling.Locale import Duckling.Resolve import Duckling.Types 

@@ -18,17 +18,17 @@   , ptree   ) where -import qualified Data.HashSet as HashSet import Data.Maybe import Data.Text (Text)+import Prelude+import qualified Data.HashSet as HashSet import qualified Data.Text as Text import qualified Data.Text.IO as Text-import Prelude  import Duckling.Api import Duckling.Dimensions.Types import Duckling.Engine-import Duckling.Lang+import Duckling.Locale import Duckling.Resolve import Duckling.Rules import Duckling.Testing.Types@@ -37,13 +37,13 @@ -- ----------------------------------------------------------------- -- API -debug :: Lang -> Text -> [Some Dimension] -> IO [Entity]-debug l = debugContext testContext {lang = l}+debug :: Locale -> Text -> [Some Dimension] -> IO [Entity]+debug locale = debugContext testContext {locale = locale} -allParses :: Lang -> Text -> [Some Dimension] -> IO [Entity]+allParses :: Locale -> Text -> [Some Dimension] -> IO [Entity] allParses l sentence targets = debugTokens sentence $ parses l sentence targets -fullParses :: Lang -> Text -> [Some Dimension] -> IO [Entity]+fullParses :: Locale -> Text -> [Some Dimension] -> IO [Entity] fullParses l sentence targets = debugTokens sentence .   filter (\(Resolved {range = Range start end}) -> start == 0 && end == n) $   parses l sentence targets@@ -56,14 +56,14 @@ -- ----------------------------------------------------------------- -- Internals -parses :: Lang -> Text -> [Some Dimension] -> [ResolvedToken]+parses :: Locale -> Text -> [Some Dimension] -> [ResolvedToken] parses l sentence targets = flip filter tokens $   \(Resolved {node = Node{token = (Token d _)}}) ->     case targets of       [] -> True       _ -> elem (This d) targets   where-    tokens = parseAndResolve rules sentence testContext {lang = l}+    tokens = parseAndResolve rules sentence testContext {locale = l}     rules = rulesFor l $ HashSet.fromList targets  debugContext :: Context -> Text -> [Some Dimension] -> IO [Entity]

@@ -21,6 +21,7 @@ import Duckling.Dimensions.Types import qualified Duckling.Dimensions.Common as CommonDimensions import qualified Duckling.Dimensions.AR as ARDimensions+import qualified Duckling.Dimensions.BG as BGDimensions import qualified Duckling.Dimensions.CS as CSDimensions import qualified Duckling.Dimensions.DA as DADimensions import qualified Duckling.Dimensions.DE as DEDimensions@@ -31,9 +32,11 @@ import qualified Duckling.Dimensions.GA as GADimensions import qualified Duckling.Dimensions.HE as HEDimensions import qualified Duckling.Dimensions.HR as HRDimensions+import qualified Duckling.Dimensions.HU as HUDimensions import qualified Duckling.Dimensions.ID as IDDimensions import qualified Duckling.Dimensions.IT as ITDimensions import qualified Duckling.Dimensions.JA as JADimensions+import qualified Duckling.Dimensions.KA as KADimensions import qualified Duckling.Dimensions.KO as KODimensions import qualified Duckling.Dimensions.MY as MYDimensions import qualified Duckling.Dimensions.NB as NBDimensions@@ -47,7 +50,7 @@ import qualified Duckling.Dimensions.UK as UKDimensions import qualified Duckling.Dimensions.VI as VIDimensions import qualified Duckling.Dimensions.ZH as ZHDimensions-import Duckling.Lang+import Duckling.Locale  allDimensions :: Lang -> [Some Dimension] allDimensions lang = CommonDimensions.allDimensions ++ langDimensions lang@@ -78,6 +81,7 @@  langDimensions :: Lang -> [Some Dimension] langDimensions AR = ARDimensions.allDimensions+langDimensions BG = BGDimensions.allDimensions langDimensions CS = CSDimensions.allDimensions langDimensions DA = DADimensions.allDimensions langDimensions DE = DEDimensions.allDimensions@@ -88,9 +92,11 @@ langDimensions GA = GADimensions.allDimensions langDimensions HE = HEDimensions.allDimensions langDimensions HR = HRDimensions.allDimensions+langDimensions HU = HUDimensions.allDimensions langDimensions ID = IDDimensions.allDimensions langDimensions IT = ITDimensions.allDimensions langDimensions JA = JADimensions.allDimensions+langDimensions KA = KADimensions.allDimensions langDimensions KO = KODimensions.allDimensions langDimensions MY = MYDimensions.allDimensions langDimensions NB = NBDimensions.allDimensions

@@ -0,0 +1,18 @@+-- Copyright (c) 2016-present, Facebook, Inc.+-- All rights reserved.+--+-- This source code is licensed under the BSD-style license found in the+-- LICENSE file in the root directory of this source tree. An additional grant+-- of patent rights can be found in the PATENTS file in the same directory.+++module Duckling.Dimensions.BG+  ( allDimensions+  ) where++import Duckling.Dimensions.Types++allDimensions :: [Some Dimension]+allDimensions =+  [ This Numeral+  ]

@@ -0,0 +1,21 @@+-- Copyright (c) 2016-present, Facebook, Inc.+-- All rights reserved.+--+-- This source code is licensed under the BSD-style license found in the+-- LICENSE file in the root directory of this source tree. An additional grant+-- of patent rights can be found in the PATENTS file in the same directory.+++module Duckling.Dimensions.HU+  ( allDimensions+  ) where++import Duckling.Dimensions.Types++allDimensions :: [Some Dimension]+allDimensions =+  [ This Duration+  , This Numeral+  , This Ordinal+  , This Time+  ]

@@ -0,0 +1,17 @@+-- Copyright (c) 2016-present, Facebook, Inc.+-- All rights reserved.+--+-- This source code is licensed under the BSD-style license found in the+-- LICENSE file in the root directory of this source tree. An additional grant+-- of patent rights can be found in the PATENTS file in the same directory.+++module Duckling.Dimensions.KA+  ( allDimensions+  ) where++import Duckling.Dimensions.Types++allDimensions :: [Some Dimension]+allDimensions =+  [ This Numeral ]

@@ -15,6 +15,7 @@ allDimensions :: [Some Dimension] allDimensions =   [ This Distance+  , This Duration   , This Numeral   , This Ordinal   , This Volume

@@ -9,18 +9,19 @@ {-# LANGUAGE OverloadedStrings #-}  module Duckling.Distance.CS.Corpus-  ( corpus ) where+  ( corpus+  ) where  import Data.String import Prelude  import Duckling.Distance.Types-import Duckling.Lang+import Duckling.Locale import Duckling.Resolve import Duckling.Testing.Types  corpus :: Corpus-corpus = (testContext {lang = CS}, allExamples)+corpus = (testContext {locale = makeLocale CS Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -9,18 +9,19 @@ {-# LANGUAGE OverloadedStrings #-}  module Duckling.Distance.ES.Corpus-  ( corpus ) where+  ( corpus+  ) where -import Prelude import Data.String+import Prelude  import Duckling.Distance.Types-import Duckling.Lang+import Duckling.Locale import Duckling.Resolve import Duckling.Testing.Types  corpus :: Corpus-corpus = (testContext {lang = ES}, allExamples)+corpus = (testContext {locale = makeLocale ES Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -25,7 +25,7 @@   { name = "<latent dist> km"   , pattern =     [ dimension Distance-    , regex "k(il(\x00f3|o))?m?(etro)?s?"+    , regex "k(il(ó|o))?m?(etro)?s?"     ]   , prod = \tokens -> case tokens of       (Token Distance dd:_) ->@@ -51,7 +51,7 @@   { name = "<dist> centimeters"   , pattern =     [ dimension Distance-    , regex "(cm|cent(\x00ed|i)m(etros?))"+    , regex "(cm|cent(í|i)m(etros?))"     ]   , prod = \tokens -> case tokens of       (Token Distance dd:_) ->

@@ -15,12 +15,12 @@ import Data.String  import Duckling.Distance.Types-import Duckling.Lang+import Duckling.Locale import Duckling.Resolve import Duckling.Testing.Types  corpus :: Corpus-corpus = (testContext {lang = FR}, allExamples)+corpus = (testContext {locale = makeLocale FR Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -25,7 +25,7 @@   { name = "<latent dist> km"   , pattern =     [ dimension Distance-    , regex "k(ilo)?m?((e|\x00e9|\x00e8)tre)?s?"+    , regex "k(ilo)?m?((e|é|è)tre)?s?"     ]   , prod = \tokens -> case tokens of       (Token Distance dd:_) ->@@ -38,7 +38,7 @@   { name = "<dist> meters"   , pattern =     [ dimension Distance-    , regex "m((e|\x00e9|\x00e8)tres?)?"+    , regex "m((e|é|è)tres?)?"     ]   , prod = \tokens -> case tokens of       (Token Distance dd:_) ->@@ -51,7 +51,7 @@   { name = "<dist> centimeters"   , pattern =     [ dimension Distance-    , regex "cm|centim(e|\x00e9|\x00e8)tres?"+    , regex "cm|centim(e|é|è)tres?"     ]   , prod = \tokens -> case tokens of       (Token Distance dd:_) ->

@@ -15,12 +15,12 @@ import Data.String  import Duckling.Distance.Types-import Duckling.Lang+import Duckling.Locale import Duckling.Resolve import Duckling.Testing.Types  corpus :: Corpus-corpus = (testContext {lang = GA}, allExamples)+corpus = (testContext {locale = makeLocale GA Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -25,7 +25,7 @@   { name = "<dist> meters"   , pattern =     [ dimension Distance-    , regex "mh?(e|\x00e9)adai?r"+    , regex "mh?(e|é)adai?r"     ]   , prod = \tokens -> case tokens of       (Token Distance dd:_) ->@@ -38,7 +38,7 @@   { name = "<dist> centimeters"   , pattern =     [ dimension Distance-    , regex "(c\\.?m\\.?|g?ch?eintimh?(e|\x00e9)adai?r)"+    , regex "(c\\.?m\\.?|g?ch?eintimh?(e|é)adai?r)"     ]   , prod = \tokens -> case tokens of       (Token Distance dd:_) ->@@ -51,7 +51,7 @@   { name = "<dist> miles"   , pattern =     [ dimension Distance-    , regex "mh?(\x00ed|i)lt?e"+    , regex "mh?(í|i)lt?e"     ]   , prod = \tokens -> case tokens of       (Token Distance dd:_) ->@@ -64,7 +64,7 @@   { name = "<latent dist> km"   , pattern =     [ dimension Distance-    , regex "(k\\.?(m\\.?)?|g?ch?ilim(e|\x00e9)adai?r)"+    , regex "(k\\.?(m\\.?)?|g?ch?ilim(e|é)adai?r)"     ]   , prod = \tokens -> case tokens of       (Token Distance dd:_) ->@@ -90,7 +90,7 @@   { name = "<latent dist> orlach"   , pattern =     [ dimension Distance-    , regex "(''|([nth]-?)?orl(ach|aigh|a(\x00ed|i)|\\.))"+    , regex "(''|([nth]-?)?orl(ach|aigh|a(í|i)|\\.))"     ]   , prod = \tokens -> case tokens of       (Token Distance dd:_) ->

@@ -14,12 +14,12 @@ import Data.String  import Duckling.Distance.Types-import Duckling.Lang+import Duckling.Locale import Duckling.Resolve import Duckling.Testing.Types  corpus :: Corpus-corpus = (testContext {lang = HR}, allExamples)+corpus = (testContext {locale = makeLocale HR Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -15,12 +15,12 @@ import Data.String  import Duckling.Distance.Types-import Duckling.Lang+import Duckling.Locale import Duckling.Resolve import Duckling.Testing.Types  corpus :: Corpus-corpus = (testContext {lang = KO}, allExamples)+corpus = (testContext {locale = makeLocale KO Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -27,7 +27,7 @@   { name = "<latent dist> yard"   , pattern =     [ dimension Distance-    , regex "y(ar)?ds?|\xc57c\xb4dc"+    , regex "y(ar)?ds?|야드"     ]   , prod = \tokens -> case tokens of       (Token Distance dd:_) ->@@ -40,7 +40,7 @@   { name = "<dist> centimeters"   , pattern =     [ dimension Distance-    , regex "cm|\xc13c(\xd2f0|\xce58)((\xbbf8|\xba54)\xd130)?"+    , regex "cm|센(티|치)((미|메)터)?"     ]   , prod = \tokens -> case tokens of       (Token Distance dd:_) ->@@ -53,9 +53,9 @@   { name = "<latent dist> feet and <latent dist> inch "   , pattern =     [ dimension Distance-    , regex "('|f(oo|ee)?ts?)|\xd53c\xd2b8"+    , regex "('|f(oo|ee)?ts?)|피트"     , dimension Distance-    , regex "(''|inch(es)?)|\xc778\xce58"+    , regex "(''|inch(es)?)|인치"     ]   , prod = \tokens -> case tokens of       (Token Distance dd:_) ->@@ -68,7 +68,7 @@   { name = "<dist> meters"   , pattern =     [ dimension Distance-    , regex "m|(\xbbf8|\xba54|\xb9e4)\xd130"+    , regex "m|(미|메|매)터"     ]   , prod = \tokens -> case tokens of       (Token Distance dd:_) ->@@ -81,7 +81,7 @@   { name = "<latent dist> feet"   , pattern =     [ dimension Distance-    , regex "('|f(oo|ee)?ts?)|\xd53c\xd2b8"+    , regex "('|f(oo|ee)?ts?)|피트"     ]   , prod = \tokens -> case tokens of       (Token Distance dd:_) ->@@ -94,7 +94,7 @@   { name = "<latent dist> km"   , pattern =     [ dimension Distance-    , regex "km|(\xd0ac|\xd0a4)\xb85c((\xbbf8|\xba54)\xd130)?"+    , regex "km|(킬|키)로((미|메)터)?"     ]   , prod = \tokens -> case tokens of       (Token Distance dd:_) ->@@ -106,7 +106,7 @@ ruleHalf = Rule   { name = "half"   , pattern =-    [ regex "\xbc18"+    [ regex "반"     ]   , prod = \tokens -> case tokens of       (Token Numeral NumeralData {TNumeral.value = v}:_) ->@@ -119,7 +119,7 @@   { name = "<dist> miles"   , pattern =     [ dimension Distance-    , regex "miles?|\xb9c8\xc77c(\xc988)?"+    , regex "miles?|마일(즈)?"     ]   , prod = \tokens -> case tokens of       (Token Distance dd:_) ->@@ -132,7 +132,7 @@   { name = "<latent dist> inch"   , pattern =     [ dimension Distance-    , regex "(''|inch(es)?)|\xc778\xce58"+    , regex "(''|inch(es)?)|인치"     ]   , prod = \tokens -> case tokens of       (Token Distance dd:_) ->

@@ -15,12 +15,12 @@ import Data.String  import Duckling.Distance.Types-import Duckling.Lang+import Duckling.Locale import Duckling.Resolve import Duckling.Testing.Types  corpus :: Corpus-corpus = (testContext {lang = NL}, allExamples)+corpus = (testContext {locale = makeLocale NL Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -15,12 +15,12 @@ import Data.String  import Duckling.Distance.Types-import Duckling.Lang+import Duckling.Locale import Duckling.Resolve import Duckling.Testing.Types  corpus :: Corpus-corpus = (testContext {lang = PT}, allExamples)+corpus = (testContext {locale = makeLocale PT Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -25,7 +25,7 @@   { name = "<latent dist> km"   , pattern =     [ dimension Distance-    , regex "k(il(\x00f3|o))?m?(etro)?s?"+    , regex "k(il(ó|o))?m?(etro)?s?"     ]   , prod = \tokens -> case tokens of       (Token Distance dd:_) ->@@ -51,7 +51,7 @@   { name = "<dist> centimeters"   , pattern =     [ dimension Distance-    , regex "(cm|cent(\x00ed|i)m(etros?))"+    , regex "(cm|cent(í|i)m(etros?))"     ]   , prod = \tokens -> case tokens of       (Token Distance dd:_) ->

@@ -15,12 +15,12 @@ import Data.String  import Duckling.Distance.Types-import Duckling.Lang+import Duckling.Locale import Duckling.Resolve import Duckling.Testing.Types  corpus :: Corpus-corpus = (testContext {lang = RO}, allExamples)+corpus = (testContext {locale = makeLocale RO Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -103,7 +103,7 @@   { name = "<dist> miles"   , pattern =     [ dimension Distance-    , regex "mil(e|a|\x0103)"+    , regex "mil(e|a|ă)"     ]   , prod = \tokens -> case tokens of       (Token Distance dd:_) ->

@@ -15,12 +15,12 @@ import Prelude  import Duckling.Distance.Types-import Duckling.Lang+import Duckling.Locale import Duckling.Resolve import Duckling.Testing.Types  corpus :: Corpus-corpus = (testContext {lang = TR}, allExamples)+corpus = (testContext {locale = makeLocale TR Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -30,7 +30,7 @@ ruleExactlyDuration = Rule   { name = "exactly <duration>"   , pattern =-    [ regex "pr(\x00e6)cis"+    [ regex "pr(æ)cis"     , dimension Duration     ]   , prod = \tokens -> case tokens of

@@ -104,7 +104,7 @@ ruleAboutDuration = Rule   { name = "about <duration>"   , pattern =-    [ regex "ungef\x00e4hr|zirka"+    [ regex "ungefähr|zirka"     , dimension Duration     ]   , prod = \tokens -> case tokens of

@@ -17,16 +17,16 @@ import Data.String  import Duckling.Duration.Types-import Duckling.Lang+import Duckling.Locale import Duckling.Resolve import Duckling.Testing.Types import Duckling.TimeGrain.Types (Grain(..))  corpus :: Corpus-corpus = (testContext {lang = FR}, allExamples)+corpus = (testContext {locale = makeLocale FR Nothing}, allExamples)  negativeCorpus :: NegativeCorpus-negativeCorpus = (testContext {lang = FR}, examples)+negativeCorpus = (testContext {locale = makeLocale FR Nothing}, examples)   where     examples =       [ "les jours"

@@ -16,13 +16,13 @@ import Data.String  import Duckling.Duration.Types-import Duckling.Lang+import Duckling.Locale import Duckling.Resolve import Duckling.Testing.Types import Duckling.TimeGrain.Types (Grain(..))  corpus :: Corpus-corpus = (testContext {lang = GA}, allExamples)+corpus = (testContext {locale = makeLocale GA Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -26,7 +26,7 @@ ruleCoics = Rule   { name = "coicís"   , pattern =-    [ regex "coic(\x00ed|i)s(\x00ed|i|e)?"+    [ regex "coic(í|i)s(í|i|e)?"     ]   , prod = \_ -> Just . Token Duration $ duration TG.Day 14   }

@@ -33,7 +33,7 @@ ruleQuarterOfAnHour = Rule   { name = "quarter of an hour"   , pattern =-    [ regex "(1/4/s \x05e9\x05e2\x05d4|\x05e8\x05d1\x05e2 \x05e9\x05e2\x05d4)"+    [ regex "(1/4/s שעה|רבע שעה)"     ]   , prod = \_ -> Just . Token Duration $ duration TG.Minute 15   }@@ -42,7 +42,7 @@ ruleHalfAnHour = Rule   { name = "half an hour"   , pattern =-    [ regex "(1/2/s \x05e9\x05e2\x05d4|\x05d7\x05e6\x05d9 \x05e9\x05e2\x05d4)"+    [ regex "(1/2/s שעה|חצי שעה)"     ]   , prod = \_ -> Just . Token Duration $ duration TG.Minute 30   }@@ -51,7 +51,7 @@ ruleThreequartersOfAnHour = Rule   { name = "three-quarters of an hour"   , pattern =-    [ regex "(3/4/s \x05e9\x05e2\x05d4|\x05e9\x05dc\x05d5\x05e9\x05ea \x05e8\x05d1\x05e2\x05d9 \x05e9\x05e2\x05d4)"+    [ regex "(3/4/s שעה|שלושת רבעי שעה)"     ]   , prod = \_ -> Just . Token Duration $ duration TG.Minute 45   }@@ -61,7 +61,7 @@   { name = "number.number hours"   , pattern =     [ regex "(\\d+)\\.(\\d+)"-    , regex "\x05e9\x05e2\x05d4|\x05e9\x05e2\x05d5\x05ea"+    , regex "שעה|שעות"     ]   , prod = \tokens -> case tokens of       (Token RegexMatch (GroupMatch (h:m:_)):_) -> do@@ -77,7 +77,7 @@   { name = "<integer> and an half hours"   , pattern =     [ Predicate isNatural-    , regex "\x05d5\x05d7\x05e6\x05d9 (\x05e9\x05e2\x05d5\x05ea|\x05e9\x05e2\x05d4)"+    , regex "וחצי (שעות|שעה)"     ]   , prod = \tokens -> case tokens of       (Token Numeral (NumeralData {TNumeral.value = v}):_) ->@@ -89,7 +89,7 @@ ruleAboutDuration = Rule   { name = "about <duration>"   , pattern =-    [ regex "(\x05d1\x05e2\x05e8\x05da|\x05e1\x05d1\x05d9\x05d1\x05d5\x05ea|\x05d1\x05e7\x05d9\x05e8\x05d5\x05d1)"+    [ regex "(בערך|סביבות|בקירוב)"     , dimension Duration     ]   , prod = \tokens -> case tokens of@@ -101,7 +101,7 @@ ruleExactlyDuration = Rule   { name = "exactly <duration>"   , pattern =-    [ regex "\x05d1\x05d3\x05d9\x05d5\x05e7"+    [ regex "בדיוק"     , dimension Duration     ]   , prod = \tokens -> case tokens of

@@ -33,7 +33,7 @@ ruleExactlyDuration = Rule   { name = "exactly <duration>"   , pattern =-    [ regex "to(c|\x010d)no"+    [ regex "to(c|č)no"     , dimension Duration     ]   , prod = \tokens -> case tokens of@@ -59,7 +59,7 @@   { name = "<integer> more <unit-of-duration>"   , pattern =     [ Predicate isNatural-    , regex "vi(s|\x0161)e|manje"+    , regex "vi(s|š)e|manje"     , dimension TimeGrain     ]   , prod = \tokens -> case tokens of@@ -74,7 +74,7 @@ ruleQuarterOfAnHour = Rule   { name = "quarter of an hour"   , pattern =-    [ regex "((1/4|frtalj|kvarat|(c|\x010d)etvrt)\\s?(h|sata)?)"+    [ regex "((1/4|frtalj|kvarat|(c|č)etvrt)\\s?(h|sata)?)"     ]   , prod = \_ -> Just . Token Duration $ duration TG.Minute 15   }@@ -111,7 +111,7 @@ ruleThreequartersOfAnHour = Rule   { name = "three-quarters of an hour"   , pattern =-    [ regex "((3/4|tri-?frtalja|tri-?kvarat|tri-?(c|\x010d)etvrt(ine)?)\\s?(h|sata)?)"+    [ regex "((3/4|tri-?frtalja|tri-?kvarat|tri-?(c|č)etvrt(ine)?)\\s?(h|sata)?)"     ]   , prod = \_ -> Just . Token Duration $ duration TG.Minute 45   }

@@ -0,0 +1,74 @@+-- Copyright (c) 2016-present, Facebook, Inc.+-- All rights reserved.+--+-- This source code is licensed under the BSD-style license found in the+-- LICENSE file in the root directory of this source tree. An additional grant+-- of patent rights can be found in the PATENTS file in the same directory.++{-# LANGUAGE OverloadedStrings #-}++module Duckling.Duration.HU.Corpus+  ( corpus ) where++import Data.String+import Prelude++import Duckling.Duration.Types+import Duckling.Locale+import Duckling.Resolve+import Duckling.Testing.Types+import Duckling.TimeGrain.Types (Grain(..))++corpus :: Corpus+corpus = (testContext {locale = makeLocale HU Nothing}, allExamples)+++allExamples :: [Example]+allExamples = concat+  [ examples (DurationData 1 Second)+             [ "egy másodperc"+             , "1 másodperc"+             ]+  , examples (DurationData 2 Minute)+             [ "2 perc"+             , "kettő perc"+             ]+  , examples (DurationData 15 Minute)+             [ "negyed óra"+             , "negyedóra"+             , "negyed-óra"+             ]+  , examples (DurationData 30 Minute)+             [ "fél óra"+             , "félóra"+             , "fél-óra"+             ]+  , examples (DurationData 45 Minute)+             [ "háromnegyed óra"+             , "háromnegyed-óra"+             , "háromnegyedóra"+             , "3/4 óra"+             , "3/4óra"+             ]+  , examples (DurationData 150 Minute)+             [ "2.5 óra"+             , "kettő és fél óra"+             , "kettő és fél-óra"+             , "kettő és félóra"+             ]+  , examples (DurationData 30 Day)+             [ "30 nap"+             ]+  , examples (DurationData 7 Week)+             [ "hét hét"+             ]+  , examples (DurationData 1 Month)+             [ "egy hónap"+             ]+  , examples (DurationData 3 Quarter)+             [ "3 negyedév"+             ]+  , examples (DurationData 2 Year)+             [ "2 év"+             ]+  ]

@@ -0,0 +1,91 @@+-- Copyright (c) 2016-present, Facebook, Inc.+-- All rights reserved.+--+-- This source code is licensed under the BSD-style license found in the+-- LICENSE file in the root directory of this source tree. An additional grant+-- of patent rights can be found in the PATENTS file in the same directory.+++{-# LANGUAGE GADTs #-}+{-# LANGUAGE OverloadedStrings #-}++module Duckling.Duration.HU.Rules+  ( rules ) where++import Control.Monad (join)+import Data.String+import Prelude+import qualified Data.Text as Text++import Duckling.Dimensions.Types+import Duckling.Duration.Helpers+import Duckling.Numeral.Helpers (parseInt, parseInteger)+import Duckling.Numeral.Types (NumeralData(..))+import Duckling.Regex.Types+import Duckling.Types+import qualified Duckling.Numeral.Types as TNumeral+import qualified Duckling.TimeGrain.Types as TG++ruleDurationQuarterOfAnHour :: Rule+ruleDurationQuarterOfAnHour = Rule+  { name = "quarter of an hour"+  , pattern =+    [ regex "(negyed[\\s-]?\x00F3ra)"+    ]+  , prod = \_ -> Just . Token Duration $ duration TG.Minute 15+  }++ruleDurationHalfAnHour :: Rule+ruleDurationHalfAnHour = Rule+  { name = "half an hour"+  , pattern =+    [ regex "(f\x00E9l[\\s-]?\x00F3ra)"+    ]+  , prod = \_ -> Just . Token Duration $ duration TG.Minute 30+  }++ruleDurationThreeQuartersOfAnHour :: Rule+ruleDurationThreeQuartersOfAnHour = Rule+  { name = "three-quarters of an hour"+  , pattern =+    [ regex "(3/4[\\s-]?óra|h\x00E1romnegyed[\\s-]?\x00F3ra)"+    ]+  , prod = \_ -> Just . Token Duration $ duration TG.Minute 45+  }++ruleDurationDotNumeralHours :: Rule+ruleDurationDotNumeralHours = Rule+  { name = "number.number hours"+  , pattern =+    [ regex "(\\d+)\\.(\\d+) óra"+    ]+  , prod = \tokens -> case tokens of+      (Token RegexMatch (GroupMatch (h:m:_)):_) -> do+        hh <- parseInteger h+        mnum <- parseInteger m+        let mden = 10 ^ Text.length m+        Just . Token Duration $ minutesFromHourMixedFraction hh mnum mden+      _ -> Nothing+  }++ruleDurationAndHalfHour :: Rule+ruleDurationAndHalfHour = Rule+  { name = "<integer> and an half hour"+  , pattern =+    [ Predicate isNatural+    , regex "\x00E9s f\x00E9l[\\s-]?\x00F3ra"+    ]+  , prod = \tokens -> case tokens of+      (Token Numeral (NumeralData {TNumeral.value = v}):_) ->+        Just . Token Duration . duration TG.Minute $ 30 + 60 * floor v+      _ -> Nothing+  }++rules :: [Rule]+rules =+  [ ruleDurationQuarterOfAnHour+  , ruleDurationHalfAnHour+  , ruleDurationThreeQuartersOfAnHour+  , ruleDurationDotNumeralHours+  , ruleDurationAndHalfHour+  ]

@@ -16,13 +16,13 @@ import Data.String  import Duckling.Duration.Types-import Duckling.Lang+import Duckling.Locale import Duckling.Resolve import Duckling.Testing.Types import Duckling.TimeGrain.Types (Grain(..))  corpus :: Corpus-corpus = (testContext {lang = JA}, allExamples)+corpus = (testContext {locale = makeLocale JA Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -16,13 +16,13 @@ import Data.String  import Duckling.Duration.Types-import Duckling.Lang+import Duckling.Locale import Duckling.Resolve import Duckling.Testing.Types import Duckling.TimeGrain.Types (Grain(..))  corpus :: Corpus-corpus = (testContext {lang = KO}, allExamples)+corpus = (testContext {locale = makeLocale KO Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -31,7 +31,7 @@   { name = "half an hour"   , pattern =     [ Predicate $ isGrain TG.Hour-    , regex "\xbc18"+    , regex "반"     ]   , prod = \_ -> Just . Token Duration $ duration TG.Minute 30   }@@ -40,7 +40,7 @@ ruleADay = Rule   { name = "a day - 하루"   , pattern =-    [ regex "\xd558\xb8e8"+    [ regex "하루"     ]   , prod = \_ -> Just . Token Duration $ duration TG.Day 1   }@@ -50,7 +50,7 @@   { name = "number.number hours"   , pattern =     [ regex "(\\d+)\\.(\\d+)"-    , regex "\xc2dc\xac04"+    , regex "시간"     ]   , prod = \tokens -> case tokens of       (Token RegexMatch (GroupMatch (h:m:_)):_) -> do@@ -66,7 +66,7 @@   { name = "<integer> and an half hours"   , pattern =     [ Predicate isNatural-    , regex "\xc2dc\xac04\xbc18"+    , regex "시간반"     ]   , prod = \tokens -> case tokens of       (Token Numeral (NumeralData {TNumeral.value = v}):_) ->@@ -78,7 +78,7 @@ ruleAboutDuration = Rule   { name = "about <duration>"   , pattern =-    [ regex "\xb300\xcda9|\xc57d"+    [ regex "대충|약"     , dimension Duration     ]   , prod = \tokens -> case tokens of@@ -90,7 +90,7 @@ ruleExactlyDuration = Rule   { name = "exactly <duration>"   , pattern =-    [ regex "\xc815\xd655\xd788"+    [ regex "정확히"     , dimension Duration     ]   , prod = \tokens -> case tokens of

@@ -16,13 +16,13 @@ import Data.String  import Duckling.Duration.Types-import Duckling.Lang+import Duckling.Locale import Duckling.Resolve import Duckling.Testing.Types import Duckling.TimeGrain.Types (Grain(..))  corpus :: Corpus-corpus = (testContext {lang = NB}, allExamples)+corpus = (testContext {locale = makeLocale NB Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -0,0 +1,83 @@+-- Copyright (c) 2016-present, Facebook, Inc.+-- All rights reserved.+--+-- This source code is licensed under the BSD-style license found in the+-- LICENSE file in the root directory of this source tree. An additional grant+-- of patent rights can be found in the PATENTS file in the same directory.+++{-# LANGUAGE OverloadedStrings #-}++module Duckling.Duration.NL.Corpus+  ( corpus+  , negativeCorpus+  ) where++import Prelude+import Data.String++import Duckling.Duration.Types+import Duckling.Locale+import Duckling.Resolve+import Duckling.Testing.Types+import Duckling.TimeGrain.Types (Grain(..))++corpus :: Corpus+corpus = (testContext {locale = makeLocale NL Nothing}, allExamples)++negativeCorpus :: NegativeCorpus+negativeCorpus = (testContext {locale = makeLocale NL Nothing}, examples)+  where+    examples =+      [ "voor maanden"+      , "in enkele dagen"+      , "secretaris"+      , "last minute"+      , "12 uurtje"+      ]++allExamples :: [Example]+allExamples = concat+  [ examples (DurationData 1 Second)+             [ "een seconde"+             , "één seconde"+             , "1 secondes"+             , "1 s"+             , "1\""+             ]+  , examples (DurationData 14 Second)+             [ "veertien seconden"+             , "14 s"+             ]+  , examples (DurationData 2 Minute)+             [ "2 min"+             , "twee minuten"+             , "2 m"+             , "2'"+             ]+  , examples (DurationData 30 Day)+             [ "30 dagen"+             ]+  , examples (DurationData 7 Week)+             [ "zeven weken"+             , "7 w"+             ]+  , examples (DurationData 1 Month)+             [ "1 mnd"+             , "een maand"+             , "één maand"+             ]+  , examples (DurationData 3 Quarter)+             [ "drie kwartier"+             ]+  , examples (DurationData 2 Year)+             [ "2 jaar"+             , "2 jaren"+             , "twee jaren"+             , "2 j"+             ]+   , examples (DurationData 150 Minute)+              [ "twee en een half uur"+              , "2,5 uur"+              ]+  ]

@@ -0,0 +1,114 @@+-- Copyright (c) 2016-present, Facebook, Inc.+-- All rights reserved.+--+-- This source code is licensed under the BSD-style license found in the+-- LICENSE file in the root directory of this source tree. An additional grant+-- of patent rights can be found in the PATENTS file in the same directory.+++{-# LANGUAGE GADTs #-}+{-# LANGUAGE OverloadedStrings #-}++module Duckling.Duration.NL.Rules+  ( rules ) where++import Control.Monad (join)+import Prelude+import Data.String+import qualified Data.Text as Text++import Duckling.Dimensions.Types+import Duckling.Duration.Helpers+import Duckling.Numeral.Helpers (parseInt, parseInteger)+import Duckling.Numeral.Types (NumeralData(..))+import Duckling.Regex.Types+import Duckling.Types+import qualified Duckling.Numeral.Types as TNumeral+import qualified Duckling.TimeGrain.Types as TG++ruleDurationQuarterOfAnHour :: Rule+ruleDurationQuarterOfAnHour = Rule+  { name = "quarter of an hour"+  , pattern = [ regex "1/4\\s?uur"]+  , prod = \_ -> Just . Token Duration $ duration TG.Minute 15+  }++ruleDurationHalfAnHour :: Rule+ruleDurationHalfAnHour = Rule+  { name = "half an hour"+  , pattern = [regex "(1/2\\s?uur|half uur)"]+  , prod = \_ -> Just . Token Duration $ duration TG.Minute 30+  }++ruleDurationThreeQuartersOfAnHour :: Rule+ruleDurationThreeQuartersOfAnHour = Rule+  { name = "three-quarters of an hour"+  , pattern = [regex "3/4\\s?uur"]+  , prod = \_ -> Just . Token Duration $ duration TG.Minute 45+  }++ruleNumeralQuotes :: Rule+ruleNumeralQuotes = Rule+  { name = "<integer> + '\""+  , pattern =+    [ Predicate isNatural+    , regex "(['\"])"+    ]+  , prod = \tokens -> case tokens of+      (Token Numeral (NumeralData {TNumeral.value = v}):+       Token RegexMatch (GroupMatch (x:_)):+       _) -> case x of+         "'"  -> Just . Token Duration . duration TG.Minute $ floor v+         "\"" -> Just . Token Duration . duration TG.Second $ floor v+         _    -> Nothing+      _ -> Nothing+  }++ruleDurationDotNumeralHours :: Rule+ruleDurationDotNumeralHours = Rule+  { name = "number,number uur"+  , pattern = [regex "(\\d+)\\,(\\d+) *(uur|uren)"]+  , prod = \tokens -> case tokens of+      (Token RegexMatch (GroupMatch (h:m:_)):_) -> do+        hh <- parseInteger h+        mnum <- parseInteger m+        let mden = 10 ^ Text.length m+        Just . Token Duration $ minutesFromHourMixedFraction hh mnum mden+      _ -> Nothing+  }++ruleDurationAndHalfHour :: Rule+ruleDurationAndHalfHour = Rule+  { name = "<integer> and an half hour"+  , pattern =+    [ Predicate isNatural+    , regex "en een half (uur|uren)"+    ]+  , prod = \tokens -> case tokens of+      (Token Numeral (NumeralData {TNumeral.value = v}):_) ->+        Just . Token Duration . duration TG.Minute $ 30 + 60 * floor v+      _ -> Nothing+  }++ruleDurationPrecision :: Rule+ruleDurationPrecision = Rule+  { name = "about|exactly <duration>"+  , pattern =+    [ regex "(ongeveer|precies|plusminus|exact)"+    , dimension Duration+    ]+    , prod = \tokens -> case tokens of+        (_:token:_) -> Just token+        _ -> Nothing+  }++rules :: [Rule]+rules =+  [ ruleDurationQuarterOfAnHour+  , ruleDurationHalfAnHour+  , ruleDurationThreeQuartersOfAnHour+  , ruleDurationDotNumeralHours+  , ruleDurationAndHalfHour+  , ruleDurationPrecision+  , ruleNumeralQuotes+  ]

@@ -16,13 +16,13 @@ import Data.String  import Duckling.Duration.Types-import Duckling.Lang+import Duckling.Locale import Duckling.Resolve import Duckling.Testing.Types import Duckling.TimeGrain.Types (Grain(..))  corpus :: Corpus-corpus = (testContext {lang = PL}, allExamples)+corpus = (testContext {locale = makeLocale PL Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -30,7 +30,7 @@ ruleHalfAnHour = Rule   { name = "half an hour"   , pattern =-    [ regex "p(o|\x00f3)(l|\x0142) godziny"+    [ regex "p(o|ó)(l|ł) godziny"     ]   , prod = \_ -> Just . Token Duration $ duration TG.Minute 30   }@@ -72,7 +72,7 @@   { name = "<integer> and an half hours"   , pattern =     [ Predicate isNatural-    , regex "i (p(o|\x00f3)(l|\x0142)) godziny"+    , regex "i (p(o|ó)(l|ł)) godziny"     ]   , prod = \tokens -> case tokens of       (Token Numeral (NumeralData {TNumeral.value = v}):_) ->@@ -96,7 +96,7 @@ ruleAboutDuration = Rule   { name = "about <duration>"   , pattern =-    [ regex "(oko(l|\x0142)o|miej wi(\x0119|e)cej|jakie(s|\x015b))"+    [ regex "(oko(l|ł)o|miej wi(ę|e)cej|jakie(s|ś))"     , dimension Duration     ]   , prod = \tokens -> case tokens of@@ -108,7 +108,7 @@ ruleExactlyDuration = Rule   { name = "exactly <duration>"   , pattern =-    [ regex "r(o|\x00f3)wno|dok(l|\x0142)adnie"+    [ regex "r(o|ó)wno|dok(l|ł)adnie"     , dimension Duration     ]   , prod = \tokens -> case tokens of

@@ -16,13 +16,13 @@ import Data.String  import Duckling.Duration.Types-import Duckling.Lang+import Duckling.Locale import Duckling.Resolve import Duckling.Testing.Types import Duckling.TimeGrain.Types (Grain(..))  corpus :: Corpus-corpus = (testContext {lang = PT}, allExamples)+corpus = (testContext {locale = makeLocale PT Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -16,13 +16,13 @@ import Data.String  import Duckling.Duration.Types-import Duckling.Lang+import Duckling.Locale import Duckling.Resolve import Duckling.Testing.Types import Duckling.TimeGrain.Types (Grain(..))  corpus :: Corpus-corpus = (testContext {lang = RO}, allExamples)+corpus = (testContext {locale = makeLocale RO Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -24,7 +24,7 @@ ruleQuarterOfAnHour = Rule   { name = "quarter of an hour"   , pattern =-    [ regex "(1/4\\s?(h|or(a|\x0103))|sfert de or(a|\x0103))"+    [ regex "(1/4\\s?(h|or(a|ă))|sfert de or(a|ă))"     ]   , prod = \_ -> Just . Token Duration $ duration TG.Minute 15   }@@ -33,7 +33,7 @@ ruleJumatateDeOra = Rule   { name = "jumatate de ora"   , pattern =-    [ regex "(1/2\\s?(h|or(a|\x0103))|jum(a|\x0103)tate (de )?or(a|\x0103))"+    [ regex "(1/2\\s?(h|or(a|ă))|jum(a|ă)tate (de )?or(a|ă))"     ]   , prod = \_ -> Just . Token Duration $ duration TG.Minute 30   }@@ -42,7 +42,7 @@ ruleTreiSferturiDeOra = Rule   { name = "trei sferturi de ora"   , pattern =-    [ regex "(3/4\\s?(h|or(a|\x0103))|trei sferturi de or(a|\x0103))"+    [ regex "(3/4\\s?(h|or(a|ă))|trei sferturi de or(a|ă))"     ]   , prod = \_ -> Just . Token Duration $ duration TG.Minute 45   }@@ -63,7 +63,7 @@ ruleExactInJurDeDuration = Rule   { name = "exact|in jur de <duration>"   , pattern =-    [ regex "(exact|aproximativ|(i|\x00ee)n jur de)"+    [ regex "(exact|aproximativ|(i|î)n jur de)"     , dimension Duration     ]   , prod = \tokens -> case tokens of

@@ -16,13 +16,13 @@ import Data.String  import Duckling.Duration.Types-import Duckling.Lang+import Duckling.Locale import Duckling.Resolve import Duckling.Testing.Types import Duckling.TimeGrain.Types (Grain(..))  corpus :: Corpus-corpus = (testContext {lang = SV}, allExamples)+corpus = (testContext {locale = makeLocale SV Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -16,13 +16,13 @@ import Prelude  import Duckling.Duration.Types-import Duckling.Lang+import Duckling.Locale import Duckling.Resolve import Duckling.Testing.Types import Duckling.TimeGrain.Types (Grain (..))  corpus :: Corpus-corpus = (testContext {lang = TR}, allExamples)+corpus = (testContext {locale = makeLocale TR Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -30,7 +30,7 @@ ruleDurationQuarterOfAnHour :: Rule ruleDurationQuarterOfAnHour = Rule   { name = "quarter of an hour"-  , pattern = [ regex "(1/4\\s?sa(at)?|\x00e7eyrek saat)" ]+  , pattern = [ regex "(1/4\\s?sa(at)?|çeyrek saat)" ]   , prod = \_ -> Just . Token Duration $ duration TG.Minute 15   } @@ -44,7 +44,7 @@ ruleDurationThreeQuartersOfAnHour :: Rule ruleDurationThreeQuartersOfAnHour = Rule   { name = "three-quarters of an hour"-  , pattern = [regex "(3/4\\s?sa(at)?|\x00fc\x00e7e \231eyrek sa(at)?)"]+  , pattern = [regex "(3/4\\s?sa(at)?|üçe \231eyrek sa(at)?)"]   , prod = \_ -> Just . Token Duration $ duration TG.Minute 45   } @@ -90,7 +90,7 @@   { name = "<integer> and an half hour"   , pattern =     [ Predicate isNatural-    , regex "bu\x00e7euk sa(at)?"+    , regex "buçeuk sa(at)?"     ]   , prod = \tokens -> case tokens of       (Token Numeral (NumeralData {TNumeral.value = v}):_) ->@@ -103,7 +103,7 @@ ruleDurationPrecision = Rule   { name = "<duration> about|exactly"   , pattern =-    [ regex "(gibi|civar\305nda|yakla\x015f\305k|tam( olarak)?)"+    [ regex "(gibi|civar\305nda|yaklaş\305k|tam( olarak)?)"     , dimension Duration     ]     , prod = \tokens -> case tokens of

@@ -12,15 +12,17 @@   ( corpus   ) where -import Prelude import Data.String+import Prelude  import Duckling.Duration.Types+import Duckling.Locale+import Duckling.Resolve import Duckling.Testing.Types import Duckling.TimeGrain.Types (Grain(..))  corpus :: Corpus-corpus = (testContext, allExamples)+corpus = (testContext {locale = makeLocale ZH Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -13,8 +13,8 @@   , negativeCorpus   ) where -import Prelude import Data.String+import Prelude  import Duckling.Email.Types import Duckling.Testing.Types

@@ -10,6 +10,7 @@  module Duckling.Email.EN.Corpus   ( corpus+  , negativeCorpus   ) where  import Data.String@@ -17,6 +18,15 @@  import Duckling.Email.Types import Duckling.Testing.Types++negativeCorpus :: NegativeCorpus+negativeCorpus = (testContext, examples)+  where+    examples =+      [ "fitness at 6.40"+      , "class at 12.00"+      , "tonight at 9.15"+      ]  corpus :: Corpus corpus = (testContext, allExamples)

@@ -13,20 +13,20 @@   ( rules ) where  import Data.String-import qualified Data.Text as Text import Prelude+import qualified Data.Text as Text  import Duckling.Dimensions.Types import Duckling.Email.Types (EmailData (..))-import qualified Duckling.Email.Types as TEmail import Duckling.Regex.Types import Duckling.Types+import qualified Duckling.Email.Types as TEmail  ruleEmailSpelledOut :: Rule ruleEmailSpelledOut = Rule   { name = "email spelled out"   , pattern =-    [ regex "([\\w\\._+-]+) at ([\\w_-]+(\\.[\\w_-]+)+)"+    [ regex "([\\w\\._+-]+) at ([\\w_-]+(\\.[a-zA-Z]+)+)"     ]   , prod = \xs -> case xs of       (Token RegexMatch (GroupMatch (m1:m2:_)):_) ->

@@ -16,12 +16,12 @@ import Prelude  import Duckling.Email.Types-import Duckling.Lang+import Duckling.Locale import Duckling.Resolve import Duckling.Testing.Types  corpus :: Corpus-corpus = (testContext {lang = FR}, allExamples)+corpus = (testContext {locale = makeLocale FR Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -16,12 +16,12 @@ import Prelude  import Duckling.Email.Types-import Duckling.Lang+import Duckling.Locale import Duckling.Resolve import Duckling.Testing.Types  corpus :: Corpus-corpus = (testContext {lang = IT}, allExamples)+corpus = (testContext {locale = makeLocale IT Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -20,25 +20,25 @@ import Control.DeepSeq import Control.Monad.Extra import Data.Aeson-import qualified Data.Array as Array import Data.ByteString (ByteString) import Data.Functor.Identity-import qualified Data.Foldable as Foldable import Data.Maybe import Data.Text (Text)-import qualified Data.List as L import Prelude+import qualified Data.Array as Array+import qualified Data.Foldable as Foldable+import qualified Data.List as L import qualified Text.Regex.PCRE as PCRE  import Duckling.Dimensions.Types-import qualified Duckling.Engine.Regex as Regex import Duckling.Regex.Types import Duckling.Resolve import Duckling.Types-import qualified Duckling.Types.Document as Document import Duckling.Types.Document (Document)-import qualified Duckling.Types.Stash as Stash import Duckling.Types.Stash (Stash)+import qualified Duckling.Engine.Regex as Regex+import qualified Duckling.Types.Document as Document+import qualified Duckling.Types.Stash as Stash  -- ----------------------------------------------------------------- -- Engine

@@ -1,55 +0,0 @@--- Copyright (c) 2016-present, Facebook, Inc.--- All rights reserved.------ This source code is licensed under the BSD-style license found in the--- LICENSE file in the root directory of this source tree. An additional grant--- of patent rights can be found in the PATENTS file in the same directory.---{-# LANGUAGE DeriveAnyClass #-}-{-# LANGUAGE DeriveGeneric #-}-{-# LANGUAGE NoRebindableSyntax #-}--module Duckling.Lang-  ( Lang(..)-  ) where--import Prelude--import Data.Hashable-import GHC.Generics-import TextShow (TextShow)-import qualified TextShow as TS--data Lang-  = AR-  | CS-  | DA-  | DE-  | EN-  | ES-  | ET-  | FR-  | GA-  | HE-  | HR-  | ID-  | IT-  | JA-  | KO-  | MY-  | NB-  | NL-  | PL-  | PT-  | RO-  | RU-  | SV-  | TR-  | UK-  | VI-  | ZH-  deriving (Bounded, Enum, Eq, Generic, Hashable, Ord, Read, Show)--instance TextShow Lang where-  showb = TS.fromString . show

@@ -0,0 +1,106 @@+-- Copyright (c) 2016-present, Facebook, Inc.+-- All rights reserved.+--+-- This source code is licensed under the BSD-style license found in the+-- LICENSE file in the root directory of this source tree. An additional grant+-- of patent rights can be found in the PATENTS file in the same directory.+++{-# LANGUAGE DeriveAnyClass #-}+{-# LANGUAGE DeriveGeneric #-}+{-# LANGUAGE NoRebindableSyntax #-}++module Duckling.Locale+  ( Lang(..)+  , Locale(..)+  , Region(..)+  , allLocales+  , makeLocale+  ) where++import Data.Hashable+import Data.HashMap.Strict (HashMap)+import Data.HashSet (HashSet)+import GHC.Generics+import Prelude+import TextShow (TextShow)+import qualified Data.HashMap.Strict as HashMap+import qualified Data.HashSet as HashSet+import qualified TextShow as TS++-- | ISO 639-1 Language.+-- See https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes+data Lang+  = AR+  | BG+  | CS+  | DA+  | DE+  | EN+  | ES+  | ET+  | FR+  | GA+  | HE+  | HR+  | HU+  | ID+  | IT+  | JA+  | KA+  | KO+  | MY+  | NB+  | NL+  | PL+  | PT+  | RO+  | RU+  | SV+  | TR+  | UK+  | VI+  | ZH+  deriving (Bounded, Enum, Eq, Generic, Hashable, Ord, Read, Show)++instance TextShow Lang where+  showb = TS.fromString . show++-- | ISO 3166-1 alpha-2 Country code (includes regions and territories).+-- See https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2+data Region+  = CA+  | CN+  | GB+  | HK+  | MO+  | TW+  | US+  deriving (Bounded, Enum, Eq, Generic, Hashable, Ord, Read, Show)++instance TextShow Region where+  showb = TS.fromString . show++data Locale = Locale Lang (Maybe Region)+  deriving (Eq, Generic, Hashable, Ord)++instance Show Locale where+  show (Locale lang Nothing) = show lang ++ "_XX"+  show (Locale lang (Just region)) = show lang ++ "_" ++ show region++instance TextShow Locale where+  showb = TS.fromString . show++makeLocale :: Lang -> Maybe Region -> Locale+makeLocale lang Nothing = Locale lang Nothing+makeLocale lang (Just region)+  | HashSet.member region locales = Locale lang $ Just region+  | otherwise = Locale lang Nothing+  where+    locales = HashMap.lookupDefault HashSet.empty lang allLocales++allLocales :: HashMap Lang (HashSet Region)+allLocales = HashMap.fromList+  [ (EN, HashSet.fromList [CA, GB, US])+  , (ZH, HashSet.fromList [CN, HK, MO, TW])+  ]

@@ -14,13 +14,13 @@ import Prelude import Data.String -import Duckling.Lang+import Duckling.Locale import Duckling.Numeral.Types import Duckling.Resolve import Duckling.Testing.Types  corpus :: Corpus-corpus = (testContext {lang = AR}, allExamples)+corpus = (testContext {locale = makeLocale AR Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -28,7 +28,7 @@ ruleInteger5 = Rule   { name = "integer 4"   , pattern =-    [ regex "(\x0623\x0631\x0628\x0639(\x0629)?)"+    [ regex "(أربع(ة)?)"     ]   , prod = \_ -> integer 4   }@@ -38,7 +38,7 @@   { name = "integer 101..999"   , pattern =     [ oneOf [100, 200 .. 900]-    , regex "\x0648"+    , regex "و"     , numberBetween 1 100     ]   , prod = \tokens -> case tokens of@@ -53,7 +53,7 @@ ruleInteger18 = Rule   { name = "integer 12"   , pattern =-    [ regex "(\x0625\x062b\x0646(\x062a)?\x0649 \x0639\x0634\x0631)"+    [ regex "(إثن(ت)?ى عشر)"     ]   , prod = \_ -> integer 12   }@@ -75,18 +75,18 @@ ruleInteger19 = Rule   { name = "integer (20..90)"   , pattern =-    [ regex "(\x0639\x0634\x0631\x0648\x0646|\x062b\x0644\x0627\x062b\x0648\x0646|\x0623\x0631\x0628\x0639\x0648\x0646|\x062e\x0645\x0633\x0648\x0646|\x0633\x062a\x0648\x0646|\x0633\x0628\x0639\x0648\x0646|\x062b\x0645\x0627\x0646\x0648\x0646|\x062a\x0633\x0639\x0648\x0646)"+    [ regex "(عشرون|ثلاثون|أربعون|خمسون|ستون|سبعون|ثمانون|تسعون)"     ]   , prod = \tokens -> case tokens of       Token RegexMatch (GroupMatch (match:_)):_ -> case match of-        "\x0639\x0634\x0631\x0648\x0646" -> integer 20-        "\x062b\x0644\x0627\x062b\x0648\x0646" -> integer 30-        "\x0623\x0631\x0628\x0639\x0648\x0646" -> integer 40-        "\x062e\x0645\x0633\x0648\x0646" -> integer 50-        "\x0633\x062a\x0648\x0646" -> integer 60-        "\x0633\x0628\x0639\x0648\x0646" -> integer 70-        "\x062b\x0645\x0627\x0646\x0648\x0646" -> integer 80-        "\x062a\x0633\x0639\x0648\x0646" -> integer 90+        "عشرون" -> integer 20+        "ثلاثون" -> integer 30+        "أربعون" -> integer 40+        "خمسون" -> integer 50+        "ستون" -> integer 60+        "سبعون" -> integer 70+        "ثمانون" -> integer 80+        "تسعون" -> integer 90         _ -> Nothing       _ -> Nothing   }@@ -96,7 +96,7 @@   { name = "integer 21..99"   , pattern =     [ numberBetween 1 10-    , regex "\x0648"+    , regex "و"     , oneOf [20, 30 .. 90]     ]   , prod = \tokens -> case tokens of@@ -147,7 +147,7 @@ ruleInteger15 = Rule   { name = "integer 11"   , pattern =-    [ regex "(\x0625\x062d\x062f\x0649 \x0639\x0634\x0631(\x0629)?)"+    [ regex "(إحدى عشر(ة)?)"     ]   , prod = \_ -> integer 11   }@@ -168,21 +168,21 @@ rulePowersOfTen = Rule   { name = "powers of tens"   , pattern =-    [ regex "(\x0645\x0627\x0626\x0629|\x0645\x0626\x0627\x062a|\x0623\x0644\x0641|\x0627\x0644\x0641|\x0622\x0644\x0627\x0641|\x0645\x0644\x0627\x064a\x064a(\x0646)?)"+    [ regex "(مائة|مئات|ألف|الف|آلاف|ملايي(ن)?)"     ]   , prod = \tokens -> case tokens of       (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of-        "\x0645\x0627\x0626\x0629" ->+        "مائة" ->           double 1e2 >>= withGrain 2 >>= withMultipliable-        "\x0645\x0626\x0627\x062a" ->+        "مئات" ->           double 1e2 >>= withGrain 2 >>= withMultipliable-        "\x0623\x0644\x0641" -> double 1e3 >>= withGrain 3 >>= withMultipliable-        "\x0627\x0644\x0641" -> double 1e3 >>= withGrain 3 >>= withMultipliable-        "\x0622\x0644\x0627\x0641" ->+        "ألف" -> double 1e3 >>= withGrain 3 >>= withMultipliable+        "الف" -> double 1e3 >>= withGrain 3 >>= withMultipliable+        "آلاف" ->           double 1e3 >>= withGrain 3 >>= withMultipliable-        "\x0645\x0644\x0627\x064a\x064a" ->+        "ملايي" ->           double 1e6 >>= withGrain 6 >>= withMultipliable-        "\x0645\x0644\x0627\x064a\x064a\x0646" ->+        "ملايين" ->           double 1e6 >>= withGrain 6 >>= withMultipliable         _ -> Nothing       _ -> Nothing@@ -192,7 +192,7 @@ ruleInteger3 = Rule   { name = "integer 2"   , pattern =-    [ regex "(\x0627\x062b\x0646\x0627\x0646|\x0627\x062b\x0646\x064a\x0646)"+    [ regex "(اثنان|اثنين)"     ]   , prod = \_ -> integer 2   }@@ -201,7 +201,7 @@ ruleInteger13 = Rule   { name = "integer 9"   , pattern =-    [ regex "(\x062a\x0633\x0639\x0629|\x062a\x0633\x0639)"+    [ regex "(تسعة|تسع)"     ]   , prod = \_ -> integer 9   }@@ -210,7 +210,7 @@ ruleInteger12 = Rule   { name = "integer 8"   , pattern =-    [ regex "(\x062b\x0645\x0627\x0646\x064a\x0629|\x062b\x0645\x0627\x0646)"+    [ regex "(ثمانية|ثمان)"     ]   , prod = \_ -> integer 8   }@@ -232,7 +232,7 @@ ruleInteger7 = Rule   { name = "integer 5"   , pattern =-    [ regex "(\x062e\x0645\x0633)(\x0629)?"+    [ regex "(خمس)(ة)?"     ]   , prod = \_ -> integer 5   }@@ -241,7 +241,7 @@ ruleInteger14 = Rule   { name = "integer 10"   , pattern =-    [ regex "(\x0639\x0634\x0631\x0629|\x0639\x0634\x0631)"+    [ regex "(عشرة|عشر)"     ]   , prod = \_ -> integer 10   }@@ -250,7 +250,7 @@ ruleInteger9 = Rule   { name = "integer 6"   , pattern =-    [ regex "(\x0633\x062a(\x0629)?)"+    [ regex "(ست(ة)?)"     ]   , prod = \_ -> integer 6   }@@ -259,7 +259,7 @@ ruleInteger = Rule   { name = "integer 0"   , pattern =-    [ regex "(\x0635\x0641\x0631)"+    [ regex "(صفر)"     ]   , prod = \_ -> integer 0   }@@ -268,7 +268,7 @@ ruleInteger4 = Rule   { name = "integer 3"   , pattern =-    [ regex "(\x062b\x0644\x0627\x062b|\x062b\x0644\x0627\x062b\x0629)"+    [ regex "(ثلاث|ثلاثة)"     ]   , prod = \_ -> integer 3   }@@ -277,7 +277,7 @@ ruleInteger2 = Rule   { name = "integer 1"   , pattern =-    [ regex "(\x0648\x0627\x062d\x062f\x0629|\x0648\x0627\x062d\x062f\x0647|\x0648\x0627\x062d\x062f)"+    [ regex "(واحدة|واحده|واحد)"     ]   , prod = \_ -> integer 1   }@@ -286,7 +286,7 @@ ruleInteger11 = Rule   { name = "integer 7"   , pattern =-    [ regex "(\x0633\x0628\x0639\x0629|\x0633\x0628\x0639)"+    [ regex "(سبعة|سبع)"     ]   , prod = \_ -> integer 7   }@@ -295,19 +295,19 @@ ruleInteger20 = Rule   { name = "integer (100..900)"   , pattern =-    [ regex "(\x0645\x0627\x0626\x0629|\x0645\x0627\x0626\x062a\x0627\x0646|\x062b\x0644\x0627\x062b\x0645\x0627\x0626\x0629|\x0623\x0631\x0628\x0639\x0645\x0627\x0626\x0629|\x062e\x0645\x0633\x0645\x0627\x0626\x0629|\x0633\x062a\x0645\x0627\x0626\x0629|\x0633\x0628\x0639\x0645\x0627\x0626\x0629|\x062b\x0645\x0627\x0646\x0645\x0627\x0626\x0629|\x062a\x0633\x0639\x0645\x0627\x0626\x0629)"+    [ regex "(مائة|مائتان|ثلاثمائة|أربعمائة|خمسمائة|ستمائة|سبعمائة|ثمانمائة|تسعمائة)"     ]   , prod = \tokens -> case tokens of       Token RegexMatch (GroupMatch (match:_)):_ -> case match of-        "\x0645\x0627\x0626\x0629" -> integer 100-        "\x0633\x0628\x0639\x0645\x0627\x0626\x0629" -> integer 700-        "\x062e\x0645\x0633\x0645\x0627\x0626\x0629" -> integer 500-        "\x0623\x0631\x0628\x0639\x0645\x0627\x0626\x0629" -> integer 400-        "\x0633\x062a\x0645\x0627\x0626\x0629" -> integer 600-        "\x0645\x0627\x0626\x062a\x0627\x0646" -> integer 200-        "\x062b\x0644\x0627\x062b\x0645\x0627\x0626\x0629" -> integer 300-        "\x062b\x0645\x0627\x0646\x0645\x0627\x0626\x0629" -> integer 800-        "\x062a\x0633\x0639\x0645\x0627\x0626\x0629" -> integer 900+        "مائة" -> integer 100+        "سبعمائة" -> integer 700+        "خمسمائة" -> integer 500+        "أربعمائة" -> integer 400+        "ستمائة" -> integer 600+        "مائتان" -> integer 200+        "ثلاثمائة" -> integer 300+        "ثمانمائة" -> integer 800+        "تسعمائة" -> integer 900         _ -> Nothing       _ -> Nothing   }@@ -317,7 +317,7 @@   { name = "number dot number"   , pattern =     [ dimension Numeral-    , regex "\x0641\x0627\x0635\x0644\x0629"+    , regex "فاصلة"     , numberWith TNumeral.grain isNothing     ]   , prod = \tokens -> case tokens of

@@ -0,0 +1,127 @@+-- Copyright (c) 2016-present, Facebook, Inc.+-- All rights reserved.+--+-- This source code is licensed under the BSD-style license found in the+-- LICENSE file in the root directory of this source tree. An additional grant+-- of patent rights can be found in the PATENTS file in the same directory.+++{-# LANGUAGE OverloadedStrings #-}++module Duckling.Numeral.BG.Corpus+  ( corpus ) where++import Data.String+import Prelude++import Duckling.Locale+import Duckling.Numeral.Types+import Duckling.Resolve+import Duckling.Testing.Types++corpus :: Corpus+corpus = (testContext {locale = makeLocale BG Nothing}, allExamples)++allExamples :: [Example]+allExamples = concat+  [ examples (NumeralValue 0)+             [ "0"+             , "нула"+             ]+  , examples (NumeralValue 1)+             [ "1"+             , "един"+             , "една"+             , "едно"+             ]+  , examples (NumeralValue 2)+             [ "2"+             , "02"+             , "две"+             , "два"+             ]+  , examples (NumeralValue 3)+             [ "3"+             , "03"+             , "три"+             ]+  , examples (NumeralValue 4)+             [ "4"+             , "04"+             , "четири"+             ]+  , examples (NumeralValue 5)+             [ "5"+             , "05"+             , "пет"+             ]+  , examples (NumeralValue 33)+             [ "33"+             , "0033"+             , "тридесет и три"+             ]+  , examples (NumeralValue 14)+             [ "14"+             , "четиринадесет"+             , "четиринайсет"+             ]+  , examples (NumeralValue 15)+             [ "15"+             , "петнадесет"+             , "петнайсет"+             ]+  , examples (NumeralValue 16)+             [ "16"+             , "шестнадесет"+             , "шестнайсет"+             ]+  , examples (NumeralValue 17)+             [ "17"+             , "седемнадесет"+             , "седемнайсет"+             ]+  , examples (NumeralValue 18)+             [ "18"+             , "осемнадесет"+             , "осемнайсет"+             ]+  , examples (NumeralValue 525)+             [ "525"+             , "петстотин двадесет и пет"+             ]+  , examples (NumeralValue 1.1)+             [ "1.1"+             , "1.10"+             , "01.10"+             , "1 цяло и 1"+             , "едно цяло и едно"+             ]+  , examples (NumeralValue 0.77)+             [ "0.77"+             , ".77"+             ]+  , examples (NumeralValue 100000)+             [ "100000"+             , "100к"+             , "100К"+             ]+  , examples (NumeralValue 3000000)+             [ "3М"+             , "3000К"+             , "3000000"+             , "3,000,000"+             ]+  , examples (NumeralValue 1200000)+             [ "1200000"+             , "1.2М"+             , "1200К"+             , ".0012Г"+             ]+  , examples (NumeralValue (-1200000))+             [ "-1200000"+             , "минус 1200000"+             , "-1.2М"+             , "-1200К"+             , "-.0012Г"+             ]+  ]

@@ -0,0 +1,273 @@+-- Copyright (c) 2016-present, Facebook, Inc.+-- All rights reserved.+--+-- This source code is licensed under the BSD-style license found in the+-- LICENSE file in the root directory of this source tree. An additional grant+-- of patent rights can be found in the PATENTS file in the same directory.+++{-# LANGUAGE GADTs #-}+{-# LANGUAGE OverloadedStrings #-}+{-# LANGUAGE NoRebindableSyntax #-}++module Duckling.Numeral.BG.Rules+  ( rules ) where++import Data.HashMap.Strict (HashMap)+import Data.Maybe+import Data.String+import Data.Text (Text)+import Prelude+import qualified Data.HashMap.Strict as HashMap+import qualified Data.Text as Text++import Duckling.Dimensions.Types+import Duckling.Numeral.Helpers+import Duckling.Numeral.Types (NumeralData (..))+import Duckling.Regex.Types+import Duckling.Types+import qualified Duckling.Numeral.Types as TNumeral++ruleIntegers :: Rule+ruleIntegers = Rule+  { name = "integer (numeric)"+  , pattern =+    [ regex "(\\d{1,18})"+    ]+  , prod = \tokens -> case tokens of+      (Token RegexMatch (GroupMatch (match:_)):_) -> do+        v <- parseInt match+        integer $ toInteger v+      _ -> Nothing+  }++zeroNineteenMap :: HashMap Text Integer+zeroNineteenMap = HashMap.fromList+  [ ( "нула", 0 )+  , ( "един", 1 )+  , ( "една", 1 )+  , ( "едно", 1 )+  , ( "два", 2 )+  , ( "две", 2 )+  , ( "три", 3 )+  , ( "четири", 4 )+  , ( "пет", 5)+  , ( "шест", 6)+  , ( "седем", 7)+  , ( "осем", 8)+  , ( "девет", 9)+  , ( "десет", 10)+  , ( "единадесет", 11 )+  , ( "единайсет", 11 )+  , ( "дванадесет", 12 )+  , ( "дванайсет", 12 )+  , ( "тринадесет", 13 )+  , ( "тринайсет", 13 )+  , ( "четиринадесет", 14)+  , ( "четиринайсет", 14)+  , ( "петнадесет", 15)+  , ( "петнайсет", 15)+  , ( "шестнадесет", 16)+  , ( "шестнайсет", 16)+  , ( "седемнадесет", 17)+  , ( "седемнайсет", 17)+  , ( "осемнадесет", 18)+  , ( "осемнайсет", 18)+  , ( "деветнадесет", 19)+  , ( "деветнайсет", 19)+  ]++ruleToNineteen :: Rule+ruleToNineteen = Rule+  { name = "number (0..19)"+  , pattern =+    [ regex "(нула|едина(де|й)сет|двана(де|й)сет|трина(де|й)сет|четирина(де|й)сет|петна(де|й)сет|шестна(де|й)сет|седемна(де|й)сет|осемна(де|й)сет|деветна(де|й)сет|един|една|едно|два|две|три|четири|пет|шест|седем|осем|девет|десет)"+    ]+  , prod = \tokens -> case tokens of+      (Token RegexMatch (GroupMatch (match:_)):_) ->+        let x = Text.toLower match in+        HashMap.lookup x zeroNineteenMap >>= integer+      _ -> Nothing+  }++ruleTens :: Rule+ruleTens = Rule+  { name = "integer (20..90)"+  , pattern =+    [ regex "((два|три|четири|пет|шест|седем|осем|девет)десет)"+    ]+  , prod = \tokens ->+      case tokens of+        (Token RegexMatch (GroupMatch (_:match:_)):_) -> do+          x <- HashMap.lookup (Text.toLower match) zeroNineteenMap+          integer $ x * 10+        _ -> Nothing+  }++rulePowersOfTen :: Rule+rulePowersOfTen = Rule+  { name = "powers of tens"+  , pattern =+    [ regex "(хиляд(а|и)|милион(а|и)?|милиард(а|и)?)"+    ]+  , prod = \tokens -> case tokens of+      (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of+        "хиляд"   -> double 1e3 >>= withGrain 3 >>= withMultipliable+        "милион"  -> double 1e6 >>= withGrain 6 >>= withMultipliable+        "милиард" -> double 1e9 >>= withGrain 9 >>= withMultipliable+        _         -> Nothing+      _ -> Nothing+  }++ruleCompositeTens :: Rule+ruleCompositeTens = Rule+  { name = "integer 21..99"+  , pattern =+    [ oneOf [20, 30..90]+    , regex "и"+    , numberBetween 1 10+    ]+  , prod = \tokens -> case tokens of+      (Token Numeral (NumeralData {TNumeral.value = tens}):+       _:+       Token Numeral (NumeralData {TNumeral.value = units}):+       _) -> double $ tens + units+      _ -> Nothing+  }++ruleHundreds :: Rule+ruleHundreds = Rule+  { name = "integer (100..900)"+  , pattern =+    [ regex "(сто|двеста|триста|(четири|пет|шест|седем|осем|девет)стотин)"+    ]+  , prod = \tokens -> case tokens of+      (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of+        "сто"          -> integer 100+        "двеста"       -> integer 200+        "триста"       -> integer 300+        "четиристотин" -> integer 400+        "петстотин"    -> integer 500+        "шестстотин"   -> integer 600+        "седемстотин"  -> integer 700+        "осемстотин"   -> integer 800+        "деветстотин"  -> integer 900+        _              -> Nothing+      _ -> Nothing+  }++ruleCompositeHundreds :: Rule+ruleCompositeHundreds = Rule+  { name = "integer 101..999"+  , pattern =+    [ oneOf [200, 300..900]+    , numberBetween 1 100+    ]+  , prod = \tokens -> case tokens of+      (Token Numeral (NumeralData {TNumeral.value = hundreds}):+       Token Numeral (NumeralData {TNumeral.value = tens}):+       _) -> double $ hundreds + tens+      _ -> Nothing+  }++ruleDotSpelledOut :: Rule+ruleDotSpelledOut = Rule+  { name = "one point 2"+  , pattern =+    [ dimension Numeral+    , regex "цяло и"+    , numberWith TNumeral.grain isNothing+    ]+  , prod = \tokens -> case tokens of+      (Token Numeral nd1:_:Token Numeral nd2:_) ->+        double $ TNumeral.value nd1 + decimalsToDouble (TNumeral.value nd2)+      _ -> Nothing+  }++ruleDecimals :: Rule+ruleDecimals = Rule+  { name = "decimal number"+  , pattern =+    [ regex "(\\d*\\.\\d+)"+    ]+  , prod = \tokens -> case tokens of+      (Token RegexMatch (GroupMatch (match:_)):_) -> parseDecimal True match+      _ -> Nothing+  }++ruleFractions :: Rule+ruleFractions = Rule+  { name = "fractional number"+  , pattern =+    [ regex "(\\d+)/(\\d+)"+    ]+  , prod = \tokens -> case tokens of+      (Token RegexMatch (GroupMatch (numerator:denominator:_)):_) -> do+        n <- parseDecimal False numerator+        d <- parseDecimal False denominator+        divide n d+      _ -> Nothing+  }++ruleCommas :: Rule+ruleCommas = Rule+  { name = "comma-separated numbers"+  , pattern =+    [ regex "(\\d+(,\\d\\d\\d)+(\\.\\d+)?)"+    ]+  , prod = \tokens -> case tokens of+      (Token RegexMatch (GroupMatch (match:_)):_) ->+        parseDouble (Text.replace (Text.singleton ',') Text.empty match) >>= double+      _ -> Nothing+  }++ruleSuffixes :: Rule+ruleSuffixes = Rule+  { name = "suffixes (K,M,G))"+  , pattern =+    [ dimension Numeral+    , regex "((к|м|г)|(К|М|Г))(?=[\\W$€¢£]|$)"+    ]+  , prod = \tokens ->+      case tokens of+        (Token Numeral nd : Token RegexMatch (GroupMatch (match : _)):_) -> do+          x <- case Text.toLower match of+            "к" -> Just 1e3+            "К" -> Just 1e3+            "м" -> Just 1e6+            "М" -> Just 1e6+            "г" -> Just 1e9+            "Г" -> Just 1e9+            _ -> Nothing+          double $ TNumeral.value nd * x+        _ -> Nothing+  }++ruleNegative :: Rule+ruleNegative = Rule+  { name = "negative numbers"+  , pattern =+    [ regex "-|минус\\s?"+    , dimension Numeral+    ]+  , prod = \tokens -> case tokens of+      (_:Token Numeral nd:_) -> double (TNumeral.value nd * (-1))+      _ -> Nothing+  }++rules :: [Rule]+rules =+  [ ruleIntegers+  , ruleToNineteen+  , ruleTens+  , rulePowersOfTen+  , ruleCompositeTens+  , ruleHundreds+  , ruleCompositeHundreds+  , ruleDotSpelledOut+  , ruleDecimals+  , ruleFractions+  , ruleCommas+  , ruleSuffixes+  , ruleNegative+  ]

@@ -14,13 +14,13 @@ import Data.String import Prelude -import Duckling.Lang+import Duckling.Locale import Duckling.Numeral.Types import Duckling.Resolve import Duckling.Testing.Types  corpus :: Corpus-corpus = (testContext {lang = CS}, allExamples)+corpus = (testContext {locale = makeLocale CS Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -50,9 +50,9 @@   , ( "dva", 2 )   , ( "dv\x0115", 2 )   , ( "t\x0159i", 3 )-  , ( "\x010dty\x0159i", 4 )+  , ( "čty\x0159i", 4 )   , ( "p\x0115t", 5)-  , ( "\x0161est", 6)+  , ( "šest", 6)   , ( "sedm", 7)   , ( "osm", 8)   , ( "dev\x0115t", 9)@@ -63,7 +63,7 @@ ruleNumeral = Rule   { name = "number (0..10)"   , pattern =-    [ regex "(nula|jed(en|n[ao])|dv(a|\x0115)|t(\x0159)i|(\x010d)ty(\x0159)i|p(\x0115)t|(\x0161)est|sedm|osm|dev(\x0115)t|deset)"+    [ regex "(nula|jed(en|n[ao])|dv(a|\x0115)|t(\x0159)i|(č)ty(\x0159)i|p(\x0115)t|(š)est|sedm|osm|dev(\x0115)t|deset)"     ]   , prod = \tokens -> case tokens of       (Token RegexMatch (GroupMatch (match:_)):_) ->

@@ -14,13 +14,13 @@ import Prelude import Data.String -import Duckling.Lang+import Duckling.Locale import Duckling.Numeral.Types import Duckling.Resolve import Duckling.Testing.Types  corpus :: Corpus-corpus = (testContext {lang = DA}, allExamples)+corpus = (testContext {locale = makeLocale DA Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -57,7 +57,7 @@ ruleFew = Rule   { name = "few"   , pattern =-    [ regex "(nogle )?f\x00e5"+    [ regex "(nogle )?få"     ]   , prod = \_ -> integer 3   }@@ -137,7 +137,7 @@   { name = "numbers suffixes (K, M, G)"   , pattern =     [ dimension Numeral-    , regex "([kmg])(?=[\\W\\$\x20ac]|$)"+    , regex "([kmg])(?=[\\W\\$€]|$)"     ]   , prod = \tokens -> case tokens of       (Token Numeral (NumeralData {TNumeral.value = v}):@@ -221,8 +221,8 @@   , ("intet", 0)   , ("en", 1)   , ("et", 1)-  , ("\x00e9n", 1)-  , ("\x00e9t", 1)+  , ("én", 1)+  , ("ét", 1)   , ("to", 2)   , ("tre", 3)   , ("fire", 4)@@ -247,7 +247,7 @@ ruleInteger = Rule   { name = "integer (0..19)"   , pattern =-    [ regex "(intet|ingen|nul|en|et|\x00e9n|\x00e9t|to|tretten|tre|fire|femten|fem|seksten|seks|syv|otte|nitten|ni|ti|elleve|tolv|fjorten|sytten|atten)"+    [ regex "(intet|ingen|nul|en|et|én|ét|to|tretten|tre|fire|femten|fem|seksten|seks|syv|otte|nitten|ni|ti|elleve|tolv|fjorten|sytten|atten)"     ]   , prod = \tokens -> case tokens of       (Token RegexMatch (GroupMatch (match:_)):_) ->

@@ -14,13 +14,13 @@ import Prelude import Data.String -import Duckling.Lang+import Duckling.Locale import Duckling.Numeral.Types import Duckling.Resolve import Duckling.Testing.Types  corpus :: Corpus-corpus = (testContext {lang = DE}, allExamples)+corpus = (testContext {locale = makeLocale DE Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -103,7 +103,7 @@ ruleInteger3 = Rule   { name = "integer ([2-9][1-9])"   , pattern =-    [ regex "(ein|zwei|drei|vier|f\x00fcnf|sechs|sieben|acht|neun)und(zwanzig|dreissig|vierzig|f\x00fcnfzig|sechzig|siebzig|achtzig|neunzig)"+    [ regex "(ein|zwei|drei|vier|fünf|sechs|sieben|acht|neun)und(zwanzig|dreissig|vierzig|fünfzig|sechzig|siebzig|achtzig|neunzig)"     ]   , prod = \tokens -> case tokens of       (Token RegexMatch (GroupMatch (m1:m2:_)):_) -> do@@ -112,7 +112,7 @@           "zwei" -> Just 2           "drei" -> Just 3           "vier" -> Just 4-          "f\x00fcnf" -> Just 5+          "fünf" -> Just 5           "sechs" -> Just 6           "sieben" -> Just 7           "acht" -> Just 8@@ -122,7 +122,7 @@           "zwanzig" -> Just 20           "dreissig" -> Just 30           "vierzig" -> Just 40-          "f\x00fcnfzig" -> Just 50+          "fünfzig" -> Just 50           "sechzig" -> Just 60           "siebzig" -> Just 70           "achtzig" -> Just 80@@ -179,7 +179,7 @@   { name = "numbers suffixes (K, M, G)"   , pattern =     [ dimension Numeral-    , regex "([kmg])(?=[\\W\\$\x20ac]|$)"+    , regex "([kmg])(?=[\\W\\$€]|$)"     ]   , prod = \tokens -> case tokens of       (Token Numeral (NumeralData {TNumeral.value = v}):@@ -246,17 +246,17 @@   , ("zwei", 2)   , ("drei", 3)   , ("vier", 4)-  , ("f\x00fcnf", 5)+  , ("fünf", 5)   , ("sechs", 6)   , ("sieben", 7)   , ("acht", 8)   , ("neun", 9)   , ("zehn", 10)   , ("elf", 11)-  , ("zw\x00f6lf", 12)+  , ("zwölf", 12)   , ("dreizehn", 13)   , ("vierzehn", 14)-  , ("f\x00fcnfzehn", 15)+  , ("fünfzehn", 15)   , ("sechzehn", 16)   , ("siebzehn", 17)   , ("achtzehn", 18)@@ -268,7 +268,7 @@   { name = "integer (0..19)"   -- e.g. fourteen must be before four,   -- otherwise four will always shadow fourteen-  , pattern = [regex "(keine?|keine?s|keiner|keinen|null|nichts|eins?(er)?|zwei|dreizehn|drei|vierzehn|vier|f\x00fcnf|sechzehn|sechs|siebzehn|sieben|achtzehn|acht|neunzehn|neun|elf|zw\x00f6lf|f\x00fcfzehn)"]+  , pattern = [regex "(keine?|keine?s|keiner|keinen|null|nichts|eins?(er)?|zwei|dreizehn|drei|vierzehn|vier|fünf|sechzehn|sechs|siebzehn|sieben|achtzehn|acht|neunzehn|neun|elf|zwölf|füfzehn)"]   , prod = \tokens -> case tokens of       (Token RegexMatch (GroupMatch (match:_)):_) ->         HashMap.lookup (Text.toLower match) zeroNineteenMap >>= integer@@ -279,7 +279,7 @@ ruleInteger = Rule   { name = "integer (0..19)"   , pattern =-    [ regex "(keine?|keine?s|keiner|keinen|null|nichts|eins?(er)?|zwei|dreizehn|drei|vierzehn|vier|f\x00fcnf|sechzehn|sechs|siebzehn|sieben|achtzehn|acht|neunzehn|neun|elf|zw\x00f6lf|f\x00fcfzehn)"+    [ regex "(keine?|keine?s|keiner|keinen|null|nichts|eins?(er)?|zwei|dreizehn|drei|vierzehn|vier|fünf|sechzehn|sechs|siebzehn|sieben|achtzehn|acht|neunzehn|neun|elf|zwölf|füfzehn)"     ]   , prod = \tokens -> case tokens of       (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of@@ -298,17 +298,17 @@         "zwei" -> integer 2         "drei" -> integer 3         "vier" -> integer 4-        "f\x00fcnf" -> integer 5+        "fünf" -> integer 5         "sechs" -> integer 6         "sieben" -> integer 7         "acht" -> integer 8         "neun" -> integer 9         "zehn" -> integer 10         "elf" -> integer 11-        "zw\x00f6lf" -> integer 12+        "zwölf" -> integer 12         "dreizehn" -> integer 13         "vierzehn" -> integer 14-        "f\x00fcnfzehn" -> integer 15+        "fünfzehn" -> integer 15         "sechzehn" -> integer 16         "siebzehn" -> integer 17         "achtzehn" -> integer 18@@ -321,14 +321,14 @@ ruleInteger2 = Rule   { name = "integer (20..90)"   , pattern =-    [ regex "(zwanzig|dreissig|vierzig|f\x00fcnfzig|sechzig|siebzig|achtzig|neunzig)"+    [ regex "(zwanzig|dreissig|vierzig|fünfzig|sechzig|siebzig|achtzig|neunzig)"     ]   , prod = \tokens -> case tokens of       (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of         "zwanzig" -> integer 20         "dreissig" -> integer 30         "vierzig" -> integer 40-        "f\x00fcnfzig" -> integer 50+        "fünfzig" -> integer 50         "sechzig" -> integer 60         "siebzig" -> integer 70         "achtzig" -> integer 80

@@ -234,7 +234,7 @@   { name = "suffixes (K,M,G))"   , pattern =     [ dimension Numeral-    , regex "(k|m|g)(?=[\\W$\x20ac\x00a2\x00a3]|$)"+    , regex "(k|m|g)(?=[\\W$€¢£]|$)"     ]   , prod = \tokens ->       case tokens of

@@ -14,13 +14,13 @@ import Prelude import Data.String -import Duckling.Lang+import Duckling.Locale import Duckling.Numeral.Types import Duckling.Resolve import Duckling.Testing.Types  corpus :: Corpus-corpus = (testContext {lang = ES}, allExamples)+corpus = (testContext {locale = makeLocale ES Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -110,12 +110,12 @@   , ( "una" , 1 )   , ( "uno" , 1 )   , ( "dos" , 2 )-  , ( "tr\x00e9s" , 3 )+  , ( "trés" , 3 )   , ( "tres" , 3 )   , ( "cuatro" , 4 )   , ( "cinco" , 5 )   , ( "seis" , 6 )-  , ( "s\x00e9is" , 6 )+  , ( "séis" , 6 )   , ( "siete" , 7 )   , ( "ocho" , 8 )   , ( "nueve" , 9 )@@ -132,7 +132,7 @@ ruleNumeral = Rule   { name = "number (0..15)"   , pattern =-    [ regex "((c|z)ero|un(o|a)?|dos|tr(\x00e9|e)s|cuatro|cinco|s(e|\x00e9)is|siete|ocho|nueve|die(z|s)|once|doce|trece|catorce|quince)"+    [ regex "((c|z)ero|un(o|a)?|dos|tr(é|e)s|cuatro|cinco|s(e|é)is|siete|ocho|nueve|die(z|s)|once|doce|trece|catorce|quince)"     ]   , prod = \tokens -> case tokens of       (Token RegexMatch (GroupMatch (match:_)):_) ->@@ -143,20 +143,20 @@ sixteenToTwentyNineMap :: HashMap.HashMap Text.Text Integer sixteenToTwentyNineMap = HashMap.fromList   [ ( "dieciseis" , 16 )-  , ( "diesis\x00e9is" , 16 )+  , ( "diesiséis" , 16 )   , ( "diesiseis" , 16 )-  , ( "diecis\x00e9is" , 16 )+  , ( "dieciséis" , 16 )   , ( "diecisiete" , 17 )   , ( "dieciocho" , 18 )   , ( "diecinueve" , 19 )   , ( "veintiuno" , 21 )   , ( "veintiuna" , 21 )   , ( "veintidos" , 22 )-  , ( "veintitr\x00e9s" , 23 )+  , ( "veintitrés" , 23 )   , ( "veintitres" , 23 )   , ( "veinticuatro" , 24 )   , ( "veinticinco" , 25 )-  , ( "veintis\x00e9is" , 26 )+  , ( "veintiséis" , 26 )   , ( "veintiseis" , 26 )   , ( "veintisiete" , 27 )   , ( "veintiocho" , 28 )@@ -167,7 +167,7 @@ ruleNumeral5 = Rule   { name = "number (16..19 21..29)"   , pattern =-    [ regex "(die(c|s)is(\x00e9|e)is|diecisiete|dieciocho|diecinueve|veintiun(o|a)|veintidos|veintitr(\x00e9|e)s|veinticuatro|veinticinco|veintis(\x00e9|e)is|veintisiete|veintiocho|veintinueve)"+    [ regex "(die(c|s)is(é|e)is|diecisiete|dieciocho|diecinueve|veintiun(o|a)|veintidos|veintitr(é|e)s|veinticuatro|veinticinco|veintis(é|e)is|veintisiete|veintiocho|veintinueve)"     ]   , prod = \tokens -> case tokens of       (Token RegexMatch (GroupMatch (match:_)):_) ->@@ -194,7 +194,7 @@   { name = "numbers suffixes (K, M, G)"   , pattern =     [ dimension Numeral-    , regex "([kmg])(?=[\\W\\$\x20ac]|$)"+    , regex "([kmg])(?=[\\W\\$€]|$)"     ]   , prod = \tokens -> case tokens of       (Token Numeral (NumeralData {TNumeral.value = v}):

@@ -14,13 +14,13 @@ import Prelude import Data.String -import Duckling.Lang+import Duckling.Locale import Duckling.Numeral.Types import Duckling.Resolve import Duckling.Testing.Types  corpus :: Corpus-corpus = (testContext {lang = ET}, allExamples)+corpus = (testContext {locale = makeLocale ET Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -77,7 +77,7 @@ ruleTen = Rule   { name = "ten"   , pattern =-    [ regex "k\x00fcmme"+    [ regex "kümme"     ]   , prod = \_ -> integer 10 >>= withGrain 1   }@@ -122,7 +122,7 @@ ruleAFew = Rule   { name = "(a )?few"   , pattern =-    [ regex "m\x00f5ni"+    [ regex "mõni"     ]   , prod = \_ -> integer 3   }@@ -158,7 +158,7 @@   { name = "numbers suffixes (K, M, G)"   , pattern =     [ dimension Numeral-    , regex "([kmg])(?=[\\W\\$\x20ac]|$)"+    , regex "([kmg])(?=[\\W\\$€]|$)"     ]   , prod = \tokens -> case tokens of       (Token Numeral (NumeralData {TNumeral.value = v}):@@ -187,12 +187,12 @@ ruleInteger = Rule   { name = "integer (0..19)"   , pattern =-    [ regex "(null|\x00fcksteist|\x00fcks|kaksteist|kaks|kolmteist|kolm|neliteist|neli|viisteist|viis|kuusteist|kuus|seitseteist|seitse|kaheksateist|kaheksa|\x00fcheksateist|\x00fcheksa|k\x00fcmme)"+    [ regex "(null|üksteist|üks|kaksteist|kaks|kolmteist|kolm|neliteist|neli|viisteist|viis|kuusteist|kuus|seitseteist|seitse|kaheksateist|kaheksa|üheksateist|üheksa|kümme)"     ]   , prod = \tokens -> case tokens of       (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of         "null" -> integer 0-        "\x00fcks" -> integer 1+        "üks" -> integer 1         "kaks" -> integer 2         "kolm" -> integer 3         "neli" -> integer 4@@ -200,9 +200,9 @@         "kuus" -> integer 6         "seitse" -> integer 7         "kaheksa" -> integer 8-        "\x00fcheksa" -> integer 9-        "k\x00fcmme" -> integer 10-        "\x00fcksteist" -> integer 11+        "üheksa" -> integer 9+        "kümme" -> integer 10+        "üksteist" -> integer 11         "kaksteist" -> integer 12         "kolmteist" -> integer 13         "neliteist" -> integer 14@@ -210,7 +210,7 @@         "kuusteist" -> integer 16         "seitseteist" -> integer 17         "kaheksateist" -> integer 18-        "\x00fcheksateist" -> integer 19+        "üheksateist" -> integer 19         _ -> Nothing       _ -> Nothing   }@@ -219,7 +219,7 @@ ruleInteger4 = Rule   { name = "integer (200..900)"   , pattern =-    [ regex "(kakssada|kolmsada|nelisada|viissada|kuussada|seitsesada|kaheksasada|\x00fcheksasada)"+    [ regex "(kakssada|kolmsada|nelisada|viissada|kuussada|seitsesada|kaheksasada|üheksasada)"     ]   , prod = \tokens -> case tokens of       (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of@@ -230,7 +230,7 @@         "kuussada"        -> integer 600 >>= withGrain 2 >>= withMultipliable         "seitsesada"      -> integer 700 >>= withGrain 2 >>= withMultipliable         "kaheksasada"     -> integer 800 >>= withGrain 2 >>= withMultipliable-        "\x00fcheksasada" -> integer 900 >>= withGrain 2 >>= withMultipliable+        "üheksasada" -> integer 900 >>= withGrain 2 >>= withMultipliable         _ -> Nothing       _ -> Nothing   }@@ -239,18 +239,18 @@ ruleInteger2 = Rule   { name = "integer (20..90)"   , pattern =-    [ regex "((kaks|kolm|neli|viis|kuus|seitse|kaheksa|(\x00fc)heksa)k(\x00fc)mmend)"+    [ regex "((kaks|kolm|neli|viis|kuus|seitse|kaheksa|(ü)heksa)k(ü)mmend)"     ]   , prod = \tokens -> case tokens of       (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of-        "kaksk\x00fcmmend" -> integer 20-        "kolmk\x00fcmmend" -> integer 30-        "nelik\x00fcmmend" -> integer 40-        "viisk\x00fcmmend" -> integer 50-        "kuusk\x00fcmmend" -> integer 60-        "seitsek\x00fcmmend" -> integer 70-        "kaheksak\x00fcmmend" -> integer 80-        "\x00fcheksak\x00fcmmend" -> integer 90+        "kakskümmend" -> integer 20+        "kolmkümmend" -> integer 30+        "nelikümmend" -> integer 40+        "viiskümmend" -> integer 50+        "kuuskümmend" -> integer 60+        "seitsekümmend" -> integer 70+        "kaheksakümmend" -> integer 80+        "üheksakümmend" -> integer 90         _ -> Nothing       _ -> Nothing   }

@@ -14,13 +14,13 @@ import Prelude import Data.String -import Duckling.Lang+import Duckling.Locale import Duckling.Numeral.Types import Duckling.Resolve import Duckling.Testing.Types  corpus :: Corpus-corpus = (testContext {lang = FR}, allExamples)+corpus = (testContext {locale = makeLocale FR Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -144,7 +144,7 @@ ruleNumeralMap :: HashMap Text Integer ruleNumeralMap = HashMap.fromList   [ ( "zero"     , 0 )-  , ( "z\x00e9ro", 0 )+  , ( "zéro", 0 )   , ( "un"       , 1 )   , ( "une"      , 1 )   , ( "deux"     , 2 )@@ -168,7 +168,7 @@ ruleNumeral = Rule   { name = "number (0..16)"   , pattern =-    [ regex "(z(e|\x00e9)ro|une?|deux|trois|quatre|cinq|six|sept|huit|neuf|dix|onze|douze|treize|quatorze|quinze|seize)"+    [ regex "(z(e|é)ro|une?|deux|trois|quatre|cinq|six|sept|huit|neuf|dix|onze|douze|treize|quatorze|quinze|seize)"     ]   , prod = \tokens -> case tokens of       (Token RegexMatch (GroupMatch (match:_)):_) ->@@ -211,7 +211,7 @@   { name = "numbers suffixes (K, M, G)"   , pattern =     [ dimension Numeral-    , regex "([kmg])(?=[\\W$\x20ac\x00a2\x00a3]|$)"+    , regex "([kmg])(?=[\\W$€¢£]|$)"     ]   , prod = \tokens -> case tokens of       (Token Numeral (NumeralData {TNumeral.value = v}):

@@ -14,13 +14,13 @@ import Prelude import Data.String -import Duckling.Lang+import Duckling.Locale import Duckling.Numeral.Types import Duckling.Resolve import Duckling.Testing.Types  corpus :: Corpus-corpus = (testContext {lang = GA}, allExamples)+corpus = (testContext {locale = makeLocale GA Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -27,7 +27,7 @@ ruleNumeralsPrefixWithNegativeOrMinus = Rule   { name = "numbers prefix with -, negative or minus"   , pattern =-    [ regex "-|m(\x00ed|i)neas(\\sa)?\\s?"+    [ regex "-|m(í|i)neas(\\sa)?\\s?"     , dimension Numeral     ]   , prod = \tokens -> case tokens of@@ -54,19 +54,19 @@ ruleNumerals2 = Rule   { name = "numbers, 1-10"   , pattern =-    [ regex "(aon|dh(\x00e1|a)|tr(\x00ed|i)|ceithre|c(\x00fa|u)ig|seacht|s(\x00e9|e)|ocht|naoi|deich)"+    [ regex "(aon|dh(á|a)|tr(í|i)|ceithre|c(ú|u)ig|seacht|s(é|e)|ocht|naoi|deich)"     ]   , prod = \tokens -> case tokens of       (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of         "aon" -> integer 1         "dha" -> integer 2-        "dh\x00e1" -> integer 2-        "tr\x00ed" -> integer 3+        "dhá" -> integer 2+        "trí" -> integer 3         "tri" -> integer 3         "ceithre" -> integer 4         "cuig" -> integer 5-        "c\x00faig" -> integer 5-        "s\x00e9" -> integer 6+        "cúig" -> integer 5+        "sé" -> integer 6         "se" -> integer 6         "seacht" -> integer 7         "ocht" -> integer 8@@ -103,7 +103,7 @@ ruleDag = Rule   { name = "déag"   , pattern =-    [ regex "d(\x00e9|e)ag"+    [ regex "d(é|e)ag"     ]   , prod = \_ -> integer 10   }@@ -113,7 +113,7 @@   { name = "numbers suffixes (K, M, G)"   , pattern =     [ dimension Numeral-    , regex "([kmg])(?=[\\W\\$\x20ac]|$)"+    , regex "([kmg])(?=[\\W\\$€]|$)"     ]   , prod = \tokens -> case tokens of       (Token Numeral (NumeralData {TNumeral.value = v}):@@ -130,15 +130,15 @@ ruleOldVigesimalNumeralsS = Rule   { name = "old vigesimal numbers, 20s"   , pattern =-    [ regex "is (dh?(\x00e1|a) fhichead|tr(\x00ed|i) fichid|ceithre fichid)"+    [ regex "is (dh?(á|a) fhichead|tr(í|i) fichid|ceithre fichid)"     ]   , prod = \tokens -> case tokens of       (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of-        "d\x00e1 fhichead" -> integer 40+        "dá fhichead" -> integer 40         "da fhichead" -> integer 40-        "dh\x00e1 fhichead" -> integer 40+        "dhá fhichead" -> integer 40         "dha fhichead" -> integer 40-        "tr\x00ed fichid" -> integer 60+        "trí fichid" -> integer 60         "tri fichid" -> integer 60         "ceithre fichid" -> integer 80         _ -> Nothing@@ -149,16 +149,16 @@ ruleOldVigesimalNumeralsS2 = Rule   { name = "old vigesimal numbers, 20s + 10"   , pattern =-    [ regex "d(\x00e9|e)ag is (fiche|dh?(\x00e1|a) fhichead|tr(\x00ed|i) fichid|ceithre fichid)"+    [ regex "d(é|e)ag is (fiche|dh?(á|a) fhichead|tr(í|i) fichid|ceithre fichid)"     ]   , prod = \tokens -> case tokens of       (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of         "fiche" -> integer 30-        "d\x00e1 fhichead" -> integer 50+        "dá fhichead" -> integer 50         "da fhichead" -> integer 50-        "dh\x00e1 fhichead" -> integer 50+        "dhá fhichead" -> integer 50         "dha fhichead" -> integer 50-        "tr\x00ed fichid" -> integer 70+        "trí fichid" -> integer 70         "tri fichid" -> integer 70         "ceithre fichid" -> integer 90         _ -> Nothing@@ -169,7 +169,7 @@ ruleAmhin = Rule   { name = "amháin"   , pattern =-    [ regex "amh(\x00e1|a)in"+    [ regex "amh(á|a)in"     ]   , prod = \_ -> integer 1   }@@ -178,21 +178,21 @@ ruleNumerals = Rule   { name = "numbers, 20-90"   , pattern =-    [ regex "(fiche|tr(\x00ed|i)ocha|daichead|caoga|seasca|seacht(\x00f3|o)|ocht(\x00f3|o)|n(\x00f3|o)cha)"+    [ regex "(fiche|tr(í|i)ocha|daichead|caoga|seasca|seacht(ó|o)|ocht(ó|o)|n(ó|o)cha)"     ]   , prod = \tokens -> case tokens of       (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of         "fiche" -> integer 20         "triocha" -> integer 30-        "tr\x00edocha" -> integer 30+        "tríocha" -> integer 30         "daichead" -> integer 40         "caoga" -> integer 50         "seasca" -> integer 60         "seachto" -> integer 70-        "seacht\x00f3" -> integer 70+        "seachtó" -> integer 70         "ochto" -> integer 80-        "ocht\x00f3" -> integer 80-        "n\x00f3cha" -> integer 90+        "ochtó" -> integer 80+        "nócha" -> integer 90         "nocha" -> integer 90         _ -> Nothing       _ -> Nothing@@ -214,21 +214,21 @@ ruleCountNumerals = Rule   { name = "count numbers"   , pattern =-    [ regex "a (n(\x00e1|a)id|haon|d(\x00f3|o)|tr(\x00ed|i)|ceathair|c(\x00fa|u)ig|s(\x00e9|e)|seacht|hocht|naoi|deich)"+    [ regex "a (n(á|a)id|haon|d(ó|o)|tr(í|i)|ceathair|c(ú|u)ig|s(é|e)|seacht|hocht|naoi|deich)"     ]   , prod = \tokens -> case tokens of       (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of         "naid" -> integer 0-        "n\x00e1id" -> integer 0+        "náid" -> integer 0         "haon" -> integer 1-        "d\x00f3" -> integer 2+        "dó" -> integer 2         "do" -> integer 2-        "tr\x00ed" -> integer 3+        "trí" -> integer 3         "tri" -> integer 3         "ceathair" -> integer 4         "cuig" -> integer 5-        "c\x00faig" -> integer 5-        "s\x00e9" -> integer 6+        "cúig" -> integer 5+        "sé" -> integer 6         "se" -> integer 6         "seacht" -> integer 7         "hocht" -> integer 8

@@ -13,13 +13,13 @@ import Prelude import Data.String -import Duckling.Lang+import Duckling.Locale import Duckling.Numeral.Types import Duckling.Resolve import Duckling.Testing.Types  corpus :: Corpus-corpus = (testContext {lang = HE}, allExamples)+corpus = (testContext {locale = makeLocale HE Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -28,7 +28,7 @@ ruleInteger5 = Rule   { name = "integer 4"   , pattern =-    [ regex "(\x05d0\x05e8\x05d1\x05e2(\x05d4)?)"+    [ regex "(ארבע(ה)?)"     ]   , prod = \_ -> integer 4   }@@ -52,7 +52,7 @@   { name = "intersect (with and)"   , pattern =     [ numberWith (fromMaybe 0 . TNumeral.grain) (>1)-    , regex "\x05d5"+    , regex "ו"     , numberWith TNumeral.multipliable not     ]   , prod = \tokens -> case tokens of@@ -82,7 +82,7 @@   { name = "integer 21..99 (with and)"   , pattern =     [ oneOf [ 20, 30..90 ]-    , regex "\x05d5"+    , regex "ו"     , numberBetween 1 10     ]   , prod = \tokens -> case tokens of@@ -97,7 +97,7 @@ ruleNumeralsPrefixWithNegativeOrMinus = Rule   { name = "numbers prefix with -, negative or minus"   , pattern =-    [ regex "-|\x05de\x05d9\x05e0\x05d5\x05e1"+    [ regex "-|מינוס"     , dimension Numeral     ]   , prod = \tokens -> case tokens of@@ -122,7 +122,7 @@ ruleInteger10 = Rule   { name = "integer 9"   , pattern =-    [ regex "(\x05ea\x05e9\x05e2(\x05d4)?)"+    [ regex "(תשע(ה)?)"     ]   , prod = \_ -> integer 9   }@@ -131,18 +131,18 @@ ruleInteger15 = Rule   { name = "integer (20..90)"   , pattern =-    [ regex "(\x05e2\x05e9\x05e8\x05d9\x05dd|\x05e9\x05dc\x05d5\x05e9\x05d9\x05dd|\x05d0\x05e8\x05d1\x05e2\x05d9\x05dd|\x05d7\x05de\x05d9\x05e9\x05d9\x05dd|\x05e9\x05d9\x05e9\x05d9\x05dd|\x05e9\x05d1\x05e2\x05d9\x05dd|\x05e9\x05de\x05d5\x05e0\x05d9\x05dd|\x05ea\x05e9\x05e2\x05d9\x05dd)"+    [ regex "(עשרים|שלושים|ארבעים|חמישים|שישים|שבעים|שמונים|תשעים)"     ]   , prod = \tokens -> case tokens of       (Token RegexMatch (GroupMatch (match:_)):_) -> case match of-        "\x05e2\x05e9\x05e8\x05d9\x05dd" -> integer 20-        "\x05e9\x05dc\x05d5\x05e9\x05d9\x05dd" -> integer 30-        "\x05d0\x05e8\x05d1\x05e2\x05d9\x05dd" -> integer 40-        "\x05d7\x05de\x05d9\x05e9\x05d9\x05dd" -> integer 50-        "\x05e9\x05d9\x05e9\x05d9\x05dd" -> integer 60-        "\x05e9\x05d1\x05e2\x05d9\x05dd" -> integer 70-        "\x05e9\x05de\x05d5\x05e0\x05d9\x05dd" -> integer 80-        "\x05ea\x05e9\x05e2\x05d9\x05dd" -> integer 90+        "עשרים" -> integer 20+        "שלושים" -> integer 30+        "ארבעים" -> integer 40+        "חמישים" -> integer 50+        "שישים" -> integer 60+        "שבעים" -> integer 70+        "שמונים" -> integer 80+        "תשעים" -> integer 90         _ -> Nothing       _ -> Nothing   }@@ -162,7 +162,7 @@ ruleInteger3 = Rule   { name = "integer 2"   , pattern =-    [ regex "(\x05e9\x05ea\x05d9\x05d9\x05dd|\x05e9\x05e0\x05d9\x05d9\x05dd)"+    [ regex "(שתיים|שניים)"     ]   , prod = \_ -> integer 2   }@@ -171,7 +171,7 @@ ruleSingle = Rule   { name = "single"   , pattern =-    [ regex "\x05d9\x05d7\x05d9\x05d3"+    [ regex "יחיד"     ]   , prod = \_ -> integer 1   }@@ -180,7 +180,7 @@ ruleInteger13 = Rule   { name = "integer 12"   , pattern =-    [ regex "(\x05e9\x05e0\x05d9\x05d9\x05dd \x05e2\x05e9\x05e8|\x05ea\x05e8\x05d9 \x05e2\x05e9\x05e8)"+    [ regex "(שניים עשר|תרי עשר)"     ]   , prod = \_ -> integer 12   }@@ -201,7 +201,7 @@ ruleInteger6 = Rule   { name = "integer 5"   , pattern =-    [ regex "(\x05d7\x05de(\x05e9|\x05d9\x05e9\x05d4))"+    [ regex "(חמ(ש|ישה))"     ]   , prod = \_ -> integer 5   }@@ -210,21 +210,21 @@ rulePowersOfTen = Rule   { name = "powers of tens"   , pattern =-    [ regex "(\x05de\x05d0(\x05d4|\x05d5\x05ea)|\x05d0\x05dc(\x05e3|\x05e4\x05d9\x05dd)|\x05de\x05d9\x05dc\x05d9\x05d5(\x05df|\x05e0\x05d9\x05dd))"+    [ regex "(מא(ה|ות)|אל(ף|פים)|מיליו(ן|נים))"     ]   , prod = \tokens -> case tokens of       (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of-        "\x05de\x05d0\x05d4"                               ->+        "מאה"                               ->           double 1e2 >>= withGrain 2 >>= withMultipliable-        "\x05de\x05d0\x05d5\x05ea"                         ->+        "מאות"                         ->           double 1e2 >>= withGrain 2 >>= withMultipliable-        "\x05d0\x05dc\x05e3"                               ->+        "אלף"                               ->           double 1e3 >>= withGrain 3 >>= withMultipliable-        "\x05d0\x05dc\x05e4\x05d9\x05dd"                   ->+        "אלפים"                   ->           double 1e3 >>= withGrain 3 >>= withMultipliable-        "\x05de\x05d9\x05dc\x05d9\x05d5\x05df"             ->+        "מיליון"             ->           double 1e6 >>= withGrain 6 >>= withMultipliable-        "\x05de\x05d9\x05dc\x05d9\x05d5\x05e0\x05d9\x05dd" ->+        "מיליונים" ->           double 1e6 >>= withGrain 6 >>= withMultipliable         _          -> Nothing       _ -> Nothing@@ -234,7 +234,7 @@ ruleInteger7 = Rule   { name = "integer 6"   , pattern =-    [ regex "(\x05e9\x05e9(\x05d4)?)"+    [ regex "(שש(ה)?)"     ]   , prod = \_ -> integer 6   }@@ -257,7 +257,7 @@ ruleInteger8 = Rule   { name = "integer 7"   , pattern =-    [ regex "(\x05e9\x05d1\x05e2(\x05d4)?)"+    [ regex "(שבע(ה)?)"     ]   , prod = \_ -> integer 7   }@@ -266,7 +266,7 @@ ruleCouple = Rule   { name = "couple"   , pattern =-    [ regex "\x05d6\x05d5\x05d2( \x05e9\x05dc)?"+    [ regex "זוג( של)?"     ]   , prod = \_ -> integer 2   }@@ -289,7 +289,7 @@ ruleInteger9 = Rule   { name = "integer 8"   , pattern =-    [ regex "(\x05e9\x05de\x05d5\x05e0\x05d4)"+    [ regex "(שמונה)"     ]   , prod = \_ -> integer 8   }@@ -298,7 +298,7 @@ ruleInteger = Rule   { name = "integer 0"   , pattern =-    [ regex "(\x05d0\x05e4\x05e1|\x05db\x05dc\x05d5\x05dd)"+    [ regex "(אפס|כלום)"     ]   , prod = \_ -> integer 0   }@@ -307,7 +307,7 @@ ruleInteger4 = Rule   { name = "integer 3"   , pattern =-    [ regex "(\x05e9\x05dc\x05d5\x05e9(\x05d4)?)"+    [ regex "(שלוש(ה)?)"     ]   , prod = \_ -> integer 3   }@@ -316,7 +316,7 @@ ruleInteger2 = Rule   { name = "integer 1"   , pattern =-    [ regex "(\x05d0\x05d7\x05d3|\x05d0\x05d7\x05ea)"+    [ regex "(אחד|אחת)"     ]   , prod = \_ -> integer 1   }@@ -325,7 +325,7 @@ ruleInteger11 = Rule   { name = "integer 10"   , pattern =-    [ regex "(\x05e2\x05e9\x05e8(\x05d4)?)"+    [ regex "(עשר(ה)?)"     ]   , prod = \_ -> integer 10   }@@ -335,7 +335,7 @@   { name = "number dot number"   , pattern =     [ dimension Numeral-    , regex "\x05e0\x05e7\x05d5\x05d3\x05d4"+    , regex "נקודה"     , numberWith TNumeral.grain isNothing     ]   , prod = \tokens -> case tokens of

@@ -13,13 +13,13 @@ import Prelude import Data.String -import Duckling.Lang+import Duckling.Locale import Duckling.Numeral.Types import Duckling.Resolve import Duckling.Testing.Types  corpus :: Corpus-corpus = (testContext {lang = HR}, allExamples)+corpus = (testContext {locale = makeLocale HR Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -98,7 +98,7 @@ ruleInteger3 = Rule   { name = "integer (100..900)"   , pattern =-    [ regex "(sto|dvjest(o|a)|tristo|(c|\x010d)etiristo|petsto|(\x0161|s)esto|sedamsto|osamsto|devetsto)"+    [ regex "(sto|dvjest(o|a)|tristo|(c|č)etiristo|petsto|(š|s)esto|sedamsto|osamsto|devetsto)"     ]   , prod = \tokens -> case tokens of       (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of@@ -131,7 +131,7 @@ rulePowersOfTen = Rule   { name = "powers of tens"   , pattern =-    [ regex "(stotin(u|a|e)|tisu(c|\x0107)(a|u|e)|milij(u|o)na?)"+    [ regex "(stotin(u|a|e)|tisu(c|ć)(a|u|e)|milij(u|o)na?)"     ]   , prod = \tokens -> case tokens of       (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of@@ -187,7 +187,7 @@   { name = "numbers suffixes (K, M, G)"   , pattern =     [ dimension Numeral-    , regex "([kmg])(?=[\\W\\$\x20ac]|$)"+    , regex "([kmg])(?=[\\W\\$€]|$)"     ]   , prod = \tokens -> case tokens of       (Token Numeral (NumeralData {TNumeral.value = v}):@@ -222,7 +222,7 @@ ruleInteger = Rule   { name = "integer (0..19)"   , pattern =-    [ regex "(ni(s|\x0161)ta|ni(s|\x0161)tica|nula|jedanaest|dvanaest|trinaest|jeda?n(a|u|o(ga?)?)?|dv(i?je)?(a|o)?(ma)?|tri(ma)?|(\x010d|c)etiri|(\x010d|c)etrnaest|petnaest|pet|(s|\x0161)esnaest|(\x0161|s)est|sedamnaest|sedam|osamnaest|osam|devetnaest|devet)"+    [ regex "(ni(s|š)ta|ni(s|š)tica|nula|jedanaest|dvanaest|trinaest|jeda?n(a|u|o(ga?)?)?|dv(i?je)?(a|o)?(ma)?|tri(ma)?|(č|c)etiri|(č|c)etrnaest|petnaest|pet|(s|š)esnaest|(š|s)est|sedamnaest|sedam|osamnaest|osam|devetnaest|devet)"     ]   , prod = \tokens -> case tokens of       (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of@@ -283,7 +283,7 @@ ruleInteger2 = Rule   { name = "integer (20..90)"   , pattern =-    [ regex "(dvadeset|trideset|(c|\x010d)etrdeset|pedeset|(\x0161|s)esdeset|sedamdeset|osamdeset|devedeset)"+    [ regex "(dvadeset|trideset|(c|č)etrdeset|pedeset|(š|s)esdeset|sedamdeset|osamdeset|devedeset)"     ]   , prod = \tokens -> case tokens of       (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of@@ -322,7 +322,7 @@   { name = "number dot number"   , pattern =     [ dimension Numeral-    , regex "cijela|to(c|\x010d)ka|zarez"+    , regex "cijela|to(c|č)ka|zarez"     , numberWith TNumeral.grain isNothing     ]   , prod = \tokens -> case tokens of

@@ -0,0 +1,98 @@+-- Copyright (c) 2016-present, Facebook, Inc.+-- All rights reserved.+--+-- This source code is licensed under the BSD-style license found in the+-- LICENSE file in the root directory of this source tree. An additional grant+-- of patent rights can be found in the PATENTS file in the same directory.+++{-# LANGUAGE OverloadedStrings #-}++module Duckling.Numeral.HU.Corpus+  ( corpus ) where++import Data.String+import Prelude++import Duckling.Locale+import Duckling.Numeral.Types+import Duckling.Resolve+import Duckling.Testing.Types++corpus :: Corpus+corpus = (testContext {locale = makeLocale HU Nothing}, allExamples)++allExamples :: [Example]+allExamples = concat+  [ examples (NumeralValue 0)+             [ "0"+             , "nulla"+             , "zéró"+             ]+  , examples (NumeralValue 1)+             [ "1"+             , "egy"+             ]+  , examples (NumeralValue 2)+             [ "kettő"+             ]+  , examples (NumeralValue 3)+             [ "három"+             ]+  , examples (NumeralValue 4)+             [ "négy"+             ]+  , examples (NumeralValue 5)+             [ "öt"+             ]+  , examples (NumeralValue 6)+             [ "hat"+             ]+  , examples (NumeralValue 7)+             [ "hét"+             ]+  , examples (NumeralValue 8)+             [ "nyolc"+             ]+  , examples (NumeralValue 9)+             [ "kilenc"+             ]+  , examples (NumeralValue 11)+             [ "tizenegy"+             ]+  , examples (NumeralValue 15)+             [ "tizenöt"+             ]+  , examples (NumeralValue 17)+             [ "tizenhét"+             ]+  , examples (NumeralValue 20)+             [ "20"+             , "húsz"+             ]+  , examples (NumeralValue 22)+             [ "huszonkettő"+             ]+  , examples (NumeralValue 24)+             [ "24"+             , "huszonnégy"+             ]+  , examples (NumeralValue 26)+             [ "huszonhat"+             ]+  , examples (NumeralValue 28)+             [ "huszonnyolc"+             ]+  , examples (NumeralValue 10)+             [ "tíz"+             ]+  , examples (NumeralValue 20)+             [ "húsz"+             ]+  , examples (NumeralValue 50)+             [ "ötven"+             ]+  , examples (NumeralValue 34)+             [ "harmincnégy"+             ]+  ]

@@ -0,0 +1,169 @@+-- Copyright (c) 2016-present, Facebook, Inc.+-- All rights reserved.+--+-- This source code is licensed under the BSD-style license found in the+-- LICENSE file in the root directory of this source tree. An additional grant+-- of patent rights can be found in the PATENTS file in the same directory.+++{-# LANGUAGE GADTs #-}+{-# LANGUAGE OverloadedStrings #-}+{-# LANGUAGE NoRebindableSyntax #-}++module Duckling.Numeral.HU.Rules+  ( rules ) where++import Data.HashMap.Strict (HashMap)+import Data.Maybe+import Data.String+import Data.Text (Text)+import Prelude+import qualified Data.HashMap.Strict as HashMap+import qualified Data.Text as Text++import Duckling.Dimensions.Types+import Duckling.Numeral.Helpers+import Duckling.Numeral.Types (NumeralData (..))+import Duckling.Regex.Types+import Duckling.Types+import qualified Duckling.Numeral.Types as TNumeral++ruleIntegerNumeric :: Rule+ruleIntegerNumeric = Rule+  { name = "integer (numeric)"+  , pattern =+    [ regex "(\\d{1,18})"+    ]+  , prod = \tokens -> case tokens of+      (Token RegexMatch (GroupMatch (match:_)):+       _) -> do+         v <- parseInt match+         integer $ toInteger v+      _ -> Nothing+  }++ruleNumeralMap :: HashMap Text Integer+ruleNumeralMap = HashMap.fromList+  [ ( "nulla", 0 )+  , ( "z\x00E9r\x00F3", 0 )+  , ( "egy", 1 )+  , ( "kett\x0151", 2 )+  , ( "h\x00E1rom", 3 )+  , ( "n\x00E9gy", 4 )+  , ( "\x00F6t", 5)+  , ( "hat", 6)+  , ( "h\x00E9t", 7)+  , ( "nyolc", 8)+  , ( "kilenc", 9)+  , ( "t\x00EDz", 10)+  ]++ruleNumeral :: Rule+ruleNumeral = Rule+  { name = "number (0..10)"+  , pattern =+    [ regex "(nulla|z\x00E9r\x00F3|egy|kett\x0151|h\x00E1rom|n\x00E9gy|\x00F6t|hat|h\x00E9t|nyolc|kilenc|t\x00EDz)"+    ]+  , prod = \tokens -> case tokens of+      (Token RegexMatch (GroupMatch (match:_)):_) ->+        HashMap.lookup (Text.toLower match) ruleNumeralMap >>= integer+      _ -> Nothing+  }++elevenToNineteenMap :: HashMap Text Integer+elevenToNineteenMap = HashMap.fromList+  [ ( "tizenegy", 11 )+  , ( "tizenkett\x0151", 12 )+  , ( "tizenh\x00E1rom", 13 )+  , ( "tizenn\x00E9gy", 14 )+  , ( "tizen\x00F6t", 15 )+  , ( "tizenhat", 16 )+  , ( "tizenh\x00E9t", 17 )+  , ( "tizennyolc", 18 )+  , ( "tizenkilenc", 19 )+  ]++ruleElevenToNineteen :: Rule+ruleElevenToNineteen = Rule+  { name = "number (11..19)"+  , pattern =+    [ regex "(tizenegy|tizenkett\x0151|tizenh\x00E1rom|tizenn\x00E9gy|tizen\x00F6t|tizenhat|tizenh\x00E9t|tizennyolc|tizenkilenc)"+    ]+  , prod = \tokens -> case tokens of+      (Token RegexMatch (GroupMatch (match:_)):_) ->+        HashMap.lookup (Text.toLower match) elevenToNineteenMap >>= integer+      _ -> Nothing+  }++twentyoneToTwentynineMap :: HashMap Text Integer+twentyoneToTwentynineMap = HashMap.fromList+  [ ( "huszonegy", 21 )+  , ( "huszonkett\x0151", 22 )+  , ( "huszonh\x00E1rom", 23 )+  , ( "huszonn\x00E9gy", 24 )+  , ( "huszon\x00F6t", 25 )+  , ( "huszonhat", 26 )+  , ( "huszonh\x00E9t", 27 )+  , ( "huszonnyolc", 28 )+  , ( "huszonkilenc", 29 )+  ]++ruleTwentyoneToTwentynine :: Rule+ruleTwentyoneToTwentynine = Rule+  { name = "number (21..29)"+  , pattern =+    [ regex "(huszonegy|huszonkett\x0151|huszonh\x00E1rom|huszonn\x00E9gy|huszon\x00F6t|huszonhat|huszonh\x00E9t|huszonnyolc|huszonkilenc)"+    ]+  , prod = \tokens -> case tokens of+      (Token RegexMatch (GroupMatch (match:_)):_) ->+        HashMap.lookup (Text.toLower match) twentyoneToTwentynineMap >>= integer+      _ -> Nothing+  }++dozensMap :: HashMap Text Integer+dozensMap = HashMap.fromList+  [ ( "h\x00FAsz", 20 )+  , ( "harminc", 30 )+  , ( "negyven", 40 )+  , ( "\x00F6tven", 50 )+  , ( "hatvan", 60 )+  , ( "hetven", 70 )+  , ( "nyolcvan", 80 )+  , ( "kilencven", 90 )+  ]++ruleTens :: Rule+ruleTens = Rule+  { name = "integer (20,30..90)"+  , pattern =+    [ regex "(h\x00FAsz|harminc|negyven|ötven|hatvan|hetven|nyolcvan|kilencven)"+    ]+  , prod = \tokens -> case tokens of+      (Token RegexMatch (GroupMatch (match:_)):_) ->+        HashMap.lookup (Text.toLower match) dozensMap >>= integer+      _ -> Nothing+  }++ruleCompositeTens :: Rule+ruleCompositeTens = Rule+  { name = "integer ([3-9][1-9])"+  , pattern =+    [ regex "(harminc|negyven|\x00F6tven|hatvan|hetven|nyolcvan|kilencven)(egy|kett\x0151|h\x00E1rom|n\x00E9gy|\x00F6t|hat|h\x00E9t|nyolc|kilenc)"+    ]+  , prod = \tokens -> case tokens of+      (Token RegexMatch (GroupMatch (m1:m2:_)):_) -> do+        v1 <- HashMap.lookup (Text.toLower m1) dozensMap+        v2 <- HashMap.lookup (Text.toLower m2) ruleNumeralMap+        integer $ v1 + v2+      _ -> Nothing+  }++rules :: [Rule]+rules =+  [ ruleIntegerNumeric+  , ruleNumeral+  , ruleElevenToNineteen+  , ruleTwentyoneToTwentynine+  , ruleTens+  , ruleCompositeTens+  ]

@@ -14,13 +14,13 @@ import Prelude import Data.String -import Duckling.Lang+import Duckling.Locale import Duckling.Numeral.Types import Duckling.Resolve import Duckling.Testing.Types  corpus :: Corpus-corpus = (testContext {lang = ID}, allExamples)+corpus = (testContext {locale = makeLocale ID Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -184,7 +184,7 @@   { name = "numbers suffixes (K, M, G)"   , pattern =     [ dimension Numeral-    , regex "([kmg])(?=[\\W\\$\x20ac]|$)"+    , regex "([kmg])(?=[\\W\\$€]|$)"     ]   , prod = \tokens -> case tokens of       (Token Numeral (NumeralData {TNumeral.value = v}):

@@ -14,13 +14,13 @@ import Prelude import Data.String -import Duckling.Lang+import Duckling.Locale import Duckling.Numeral.Types import Duckling.Resolve import Duckling.Testing.Types  corpus :: Corpus-corpus = (testContext {lang = IT}, allExamples)+corpus = (testContext {locale = makeLocale IT Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -174,7 +174,7 @@   { name = "numbers suffixes (K, M, G)"   , pattern =     [ dimension Numeral-    , regex "([kmg])(?=[\\W\\$\x20ac]|$)"+    , regex "([kmg])(?=[\\W\\$€]|$)"     ]   , prod = \tokens -> case tokens of       (Token Numeral (NumeralData {TNumeral.value = v}):@@ -191,14 +191,14 @@ ruleNumeral4 = Rule   { name = "number (21..29 31..39 41..49 51..59 61..69 71..79 81..89 91..99)"   , pattern =-    [ regex "((venti|trenta|quaranta|cinquanta|sessanta|settanta|ottanta|novanta)(due|tre|tr\x00e9|quattro|cinque|sei|sette|nove))|((vent|trent|quarant|cinquant|sessant|settant|ottant|novant)(uno|otto))"+    [ regex "((venti|trenta|quaranta|cinquanta|sessanta|settanta|ottanta|novanta)(due|tre|tré|quattro|cinque|sei|sette|nove))|((vent|trent|quarant|cinquant|sessant|settant|ottant|novant)(uno|otto))"     ]   , prod = \tokens -> case tokens of       (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of         "ventuno" -> integer 21         "ventidue" -> integer 22         "ventitre" -> integer 23-        "ventitr\x00e9" -> integer 23+        "ventitré" -> integer 23         "ventiquattro" -> integer 24         "venticinque" -> integer 25         "ventisei" -> integer 26@@ -208,7 +208,7 @@         "trentuno" -> integer 31         "trentadue" -> integer 32         "trentatre" -> integer 33-        "trentatr\x00e9" -> integer 33+        "trentatré" -> integer 33         "trentaquattro" -> integer 34         "trentacinque" -> integer 35         "trentasei" -> integer 36@@ -218,7 +218,7 @@         "quarantuno" -> integer 41         "quarantadue" -> integer 42         "quarantatre" -> integer 43-        "quarantatr\x00e9" -> integer 43+        "quarantatré" -> integer 43         "quarantaquattro" -> integer 44         "quarantacinque" -> integer 45         "quarantasei" -> integer 46@@ -228,7 +228,7 @@         "cinquantuno" -> integer 51         "cinquantadue" -> integer 52         "cinquantatre" -> integer 53-        "cinquantatr\x00e9" -> integer 53+        "cinquantatré" -> integer 53         "cinquantaquattro" -> integer 54         "cinquantacinque" -> integer 55         "cinquantasei" -> integer 56@@ -237,7 +237,7 @@         "cinquantanove" -> integer 59         "sessantuno" -> integer 61         "sessantadue" -> integer 62-        "sessantatr\x00e9" -> integer 63+        "sessantatré" -> integer 63         "sessantatre" -> integer 63         "sessantaquattro" -> integer 64         "sessantacinque" -> integer 65@@ -247,7 +247,7 @@         "sessantanove" -> integer 69         "settantuno" -> integer 71         "settantadue" -> integer 72-        "settantatr\x00e9" -> integer 73+        "settantatré" -> integer 73         "settantatre" -> integer 73         "settantaquattro" -> integer 74         "settantacinque" -> integer 75@@ -257,7 +257,7 @@         "settantanove" -> integer 79         "ottantuno" -> integer 81         "ottantadue" -> integer 82-        "ottantatr\x00e9" -> integer 83+        "ottantatré" -> integer 83         "ottantatre" -> integer 83         "ottantaquattro" -> integer 84         "ottantacinque" -> integer 85@@ -268,7 +268,7 @@         "novantuno" -> integer 91         "novantadue" -> integer 92         "novantatre" -> integer 93-        "novantatr\x00e9" -> integer 93+        "novantatré" -> integer 93         "novantaquattro" -> integer 94         "novantacinque" -> integer 95         "novantasei" -> integer 96

@@ -14,13 +14,13 @@ import Prelude import Data.String -import Duckling.Lang+import Duckling.Locale import Duckling.Numeral.Types import Duckling.Resolve import Duckling.Testing.Types  corpus :: Corpus-corpus = (testContext {lang = JA}, allExamples)+corpus = (testContext {locale = makeLocale JA Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -12,7 +12,10 @@ module Duckling.Numeral.JA.Rules   ( rules ) where +import qualified Data.HashMap.Strict as HashMap import qualified Data.Text as Text+import Data.HashMap.Strict (HashMap)+import Data.Text (Text) import Prelude import Data.String @@ -27,7 +30,7 @@ ruleInteger5 = Rule   { name = "integer (100)"   , pattern =-    [ regex "\x767e"+    [ regex "百"     ]   , prod = \_ -> integer 100   }@@ -36,7 +39,7 @@ ruleNumeralsPrefixWithNegativeOrMinus = Rule   { name = "numbers prefix with -, negative or minus"   , pattern =-    [ regex "-|\x30de\x30a4\x30ca\x30b9\\s?|\x8ca0\\s?"+    [ regex "-|マイナス\\s?|負\\s?"     , dimension Numeral     ]   , prod = \tokens -> case tokens of@@ -44,30 +47,6 @@       _ -> Nothing   } -ruleInteger17 :: Rule-ruleInteger17 = Rule-  { name = "integer (0..10)"-  , pattern =-    [ regex "(\x30bc\x30ed|\x96f6|\x4e00|\x4e8c|\x4e09|\x56db|\x4e94|\x516d|\x4e03|\x516b|\x4e5d|\x5341)"-    ]-  , prod = \tokens -> case tokens of-      (Token RegexMatch (GroupMatch (match:_)):_) -> case match of-        "\x30bc\x30ed" -> integer 0-        "\x96f6" -> integer 0-        "\x4e00" -> integer 1-        "\x4e8c" -> integer 2-        "\x4e09" -> integer 3-        "\x56db" -> integer 4-        "\x4e94" -> integer 5-        "\x516d" -> integer 6-        "\x4e03" -> integer 7-        "\x516b" -> integer 8-        "\x4e5d" -> integer 9-        "\x5341" -> integer 10-        _ -> Nothing-      _ -> Nothing-  }- ruleIntegerNumeric :: Rule ruleIntegerNumeric = Rule   { name = "integer (numeric)"@@ -85,7 +64,7 @@ ruleInteger10 = Rule   { name = "integer (1000..1999)"   , pattern =-    [ regex "\x5343"+    [ regex "千"     , numberBetween 1 1000     ]   , prod = \tokens -> case tokens of@@ -111,7 +90,7 @@   { name = "integer (20000..90000)"   , pattern =     [ numberBetween 2 10-    , regex "\x4e07"+    , regex "万"     ]   , prod = \tokens -> case tokens of       (Token Numeral (NumeralData {TNumeral.value = v}):_) -> double $ v * 10000@@ -134,7 +113,7 @@   { name = "<number>个"   , pattern =     [ dimension Numeral-    , regex "\x4e2a"+    , regex "个"     ]   , prod = \tokens -> case tokens of       (token:_) -> Just token@@ -146,7 +125,7 @@   { name = "integer (20..90)"   , pattern =     [ numberBetween 2 10-    , regex "\x5341"+    , regex "十"     ]   , prod = \tokens -> case tokens of       (Token Numeral (NumeralData {TNumeral.value = v}):_) -> double $ v * 10@@ -157,7 +136,7 @@ ruleInteger13 = Rule   { name = "integer (10000)"   , pattern =-    [ regex "\x4e07"+    [ regex "万"     ]   , prod = \_ -> integer 10000   }@@ -166,7 +145,7 @@ ruleInteger6 = Rule   { name = "integer (100..199)"   , pattern =-    [ regex "\x767e"+    [ regex "百"     , numberBetween 1 100     ]   , prod = \tokens -> case tokens of@@ -193,15 +172,15 @@   { name = "numbers suffixes (K, M, G, 千, 万)"   , pattern =     [ dimension Numeral-    , regex "(k|m|g|\x5343|\x4e07)"+    , regex "(k|m|g|千|万)"     ]   , prod = \tokens -> case tokens of       (Token Numeral (NumeralData {TNumeral.value = v}):        Token RegexMatch (GroupMatch (match:_)):        _) -> case Text.toLower match of           "k"      -> double $ v * 1e3-          "\x5343" -> double $ v * 1e3-          "\x4e07" -> double $ v * 1e4+          "千" -> double $ v * 1e3+          "万" -> double $ v * 1e4           "m"      -> double $ v * 1e6           "g"      -> double $ v * 1e9           _ -> Nothing@@ -213,7 +192,7 @@   { name = "integer (200..900)"   , pattern =     [ numberBetween 2 10-    , regex "\x767e"+    , regex "百"     ]   , prod = \tokens -> case tokens of       (Token Numeral (NumeralData {TNumeral.value = v}):_) -> double $ v * 100@@ -224,7 +203,7 @@ ruleInteger14 = Rule   { name = "integer (10000..19999)"   , pattern =-    [ regex "\x4e07"+    [ regex "万"     , numberBetween 1 10000     ]   , prod = \tokens -> case tokens of@@ -265,32 +244,36 @@ ruleInteger9 = Rule   { name = "integer (1000)"   , pattern =-    [ regex "\x5343"+    [ regex "千"     ]   , prod = \_ -> integer 1000   } +integerMap :: HashMap Text Integer+integerMap = HashMap.fromList+  [ ("零", 0)+  , ("ゼロ", 0)+  , ("一", 1)+  , ("二", 2)+  , ("三", 3)+  , ("四", 4)+  , ("五", 5)+  , ("六", 6)+  , ("七", 7)+  , ("八", 8)+  , ("九", 9)+  , ("十", 10)+  ]+ ruleInteger :: Rule ruleInteger = Rule   { name = "integer (0..10)"   , pattern =-    [ regex "\x30bc\x30ed|\x96f6|\x4e00|\x4e8c|\x4e09|\x56db|\x4e94|\x516d|\x4e03|\x516b|\x4e5d|\x5341"+    [ regex "(ゼロ|零|一|二|三|四|五|六|七|八|九|十)"     ]   , prod = \tokens -> case tokens of-      (Token RegexMatch (GroupMatch (match:_)):_) -> case match of-        "\x96f6" -> integer 0-        "\x30bc\x30ed" -> integer 0-        "\x4e00" -> integer 1-        "\x4e8c" -> integer 2-        "\x4e09" -> integer 3-        "\x56db" -> integer 4-        "\x4e94" -> integer 5-        "\x516d" -> integer 6-        "\x4e03" -> integer 7-        "\x516b" -> integer 8-        "\x4e5d" -> integer 9-        "\x5341" -> integer 10-        _ -> Nothing+      (Token RegexMatch (GroupMatch (match:_)):_) ->+        HashMap.lookup (Text.toLower match) integerMap >>= integer       _ -> Nothing   } @@ -312,7 +295,7 @@ ruleInteger2 = Rule   { name = "integer (11..19)"   , pattern =-    [ regex "\x5341"+    [ regex "十"     , numberBetween 1 10     ]   , prod = \tokens -> case tokens of@@ -325,7 +308,7 @@   { name = "integer (2000..9000)"   , pattern =     [ numberBetween 2 10-    , regex "\x5343"+    , regex "千"     ]   , prod = \tokens -> case tokens of       (Token Numeral (NumeralData {TNumeral.value = v}):_) -> double $ v * 1000@@ -356,7 +339,6 @@   , ruleInteger14   , ruleInteger15   , ruleInteger16-  , ruleInteger17   , ruleInteger2   , ruleInteger3   , ruleInteger4

@@ -0,0 +1,43 @@+-- Copyright (c) 2016-present, Facebook, Inc.+-- All rights reserved.+--+-- This source code is licensed under the BSD-style license found in the+-- LICENSE file in the root directory of this source tree. An additional grant+-- of patent rights can be found in the PATENTS file in the same directory.+++{-# LANGUAGE OverloadedStrings #-}++module Duckling.Numeral.KA.Corpus+  ( corpus ) where++import Data.String+import Prelude++import Duckling.Locale+import Duckling.Numeral.Types+import Duckling.Resolve+import Duckling.Testing.Types++corpus :: Corpus+corpus = (testContext {locale = makeLocale KA Nothing}, allExamples)++allExamples :: [Example]+allExamples = concat+  [ examples (NumeralValue 0)+             [ "0"+             , "ნული"+             ]+  , examples (NumeralValue 1)+             [ "1"+             , "ერთი"+             ]+  , examples (NumeralValue 2)+             [ "2"+             , "ორი"+             ]+  , examples (NumeralValue 3)+             [ "3"+             , "სამი"+             ]+  ]

@@ -0,0 +1,75 @@+-- Copyright (c) 2016-present, Facebook, Inc.+-- All rights reserved.+--+-- This source code is licensed under the BSD-style license found in the+-- LICENSE file in the root directory of this source tree. An additional grant+-- of patent rights can be found in the PATENTS file in the same directory.+++{-# LANGUAGE GADTs #-}+{-# LANGUAGE OverloadedStrings #-}++module Duckling.Numeral.KA.Rules+  ( rules ) where++import Data.HashMap.Strict (HashMap)+import Data.Maybe+import Data.String+import Data.Text (Text)+import Prelude+import qualified Data.HashMap.Strict as HashMap+import qualified Data.Text as Text++import Duckling.Dimensions.Types+import Duckling.Numeral.Helpers+import Duckling.Numeral.Types (NumeralData (..))+import Duckling.Regex.Types+import Duckling.Types+import qualified Duckling.Numeral.Types as TNumeral++ruleIntegerNumeric :: Rule+ruleIntegerNumeric = Rule+  { name = "integer (numeric)"+  , pattern =+    [ regex "(\\d{1,18})"+    ]+  , prod = \tokens -> case tokens of+      (Token RegexMatch (GroupMatch (match:_)):+       _) -> do+         v <- parseInt match+         integer $ toInteger v+      _ -> Nothing+  }++ruleNumeralMap :: HashMap Text Integer+ruleNumeralMap = HashMap.fromList+  [ ( "ნული", 0 )+  , ( "ერთი", 1 )+  , ( "ორი", 2 )+  , ( "სამი", 3 )+  , ( "ოთხი", 4 )+  , ( "ხუთი", 5)+  , ( "ექვსი", 6)+  , ( "შვიდი", 7)+  , ( "რვა", 8)+  , ( "ცხრა", 9)+  , ( "ათი", 10)+  ]++ruleNumeral :: Rule+ruleNumeral = Rule+  { name = "number (0..10)"+  , pattern =+    [ regex "(ნული|ერთი|ორი|სამი|ოთხი|ხუთი|ექვსი|შვიდი|რვა|ცხრა|ათი)"+    ]+  , prod = \tokens -> case tokens of+      (Token RegexMatch (GroupMatch (match:_)):_) ->+        HashMap.lookup (Text.toLower match) ruleNumeralMap >>= integer+      _ -> Nothing+  }++rules :: [Rule]+rules =+  [ ruleIntegerNumeric+  , ruleNumeral+  ]

@@ -14,13 +14,13 @@ import Prelude import Data.String -import Duckling.Lang+import Duckling.Locale import Duckling.Numeral.Types import Duckling.Resolve import Duckling.Testing.Types  corpus :: Corpus-corpus = (testContext {lang = KO}, allExamples)+corpus = (testContext {locale = makeLocale KO Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -28,15 +28,15 @@ ruleIntegerForOrdinals = Rule   { name = "integer (1..4) - for ordinals"   , pattern =-    [ regex "(\xd55c|\xccab|\xb450|\xc138|\xb124)"+    [ regex "(한|첫|두|세|네)"     ]   , prod = \tokens -> case tokens of       (Token RegexMatch (GroupMatch (match:_)):_) -> case match of-        "\xd55c" -> integer 1-        "\xccab" -> integer 1-        "\xb450" -> integer 2-        "\xc138" -> integer 3-        "\xb124" -> integer 4+        "한" -> integer 1+        "첫" -> integer 1+        "두" -> integer 2+        "세" -> integer 3+        "네" -> integer 4         _ -> Nothing       _ -> Nothing   }@@ -58,7 +58,7 @@ ruleFew = Rule   { name = "few 몇"   , pattern =-    [ regex "\xba87"+    [ regex "몇"     ]   , prod = \_ -> integer 3   }@@ -106,7 +106,7 @@ ruleNumeralsPrefixWithOr = Rule   { name = "numbers prefix with -, 마이너스, or 마이나스"   , pattern =-    [ regex "-|\xb9c8\xc774\xb108\xc2a4\\s?|\xb9c8\xc774\xb098\xc2a4\\s?"+    [ regex "-|마이너스\\s?|마이나스\\s?"     , dimension Numeral     ]   , prod = \tokens -> case tokens of@@ -118,7 +118,7 @@ ruleHalf = Rule   { name = "half - 반"   , pattern =-    [ regex "\xbc18"+    [ regex "반"     ]   , prod = \_ -> double 0.5   }@@ -127,7 +127,7 @@ ruleInteger = Rule   { name = "integer 0"   , pattern =-    [ regex "\xc601|\xacf5|\xbe75"+    [ regex "영|공|빵"     ]   , prod = \_ -> integer 0   }@@ -136,19 +136,19 @@ ruleIntegerTypeAndOrdinals = Rule   { name = "integer (20..90) - TYPE 2 and ordinals"   , pattern =-    [ regex "(\xc5f4|\xc2a4\xbb3c|\xc11c\xb978|\xb9c8\xd754|\xc270|\xc608\xc21c|\xc77c\xd754|\xc5ec\xb4e0|\xc544\xd754)"+    [ regex "(열|스물|서른|마흔|쉰|예순|일흔|여든|아흔)"     ]   , prod = \tokens -> case tokens of       (Token RegexMatch (GroupMatch (match:_)):_) -> case match of-        "\xc5f4" -> integer 10-        "\xc2a4\xbb3c" -> integer 20-        "\xc11c\xb978" -> integer 30-        "\xb9c8\xd754" -> integer 40-        "\xc270" -> integer 50-        "\xc608\xc21c" -> integer 60-        "\xc77c\xd754" -> integer 70-        "\xc5ec\xb4e0" -> integer 80-        "\xc544\xd754" -> integer 90+        "열" -> integer 10+        "스물" -> integer 20+        "서른" -> integer 30+        "마흔" -> integer 40+        "쉰" -> integer 50+        "예순" -> integer 60+        "일흔" -> integer 70+        "여든" -> integer 80+        "아흔" -> integer 90         _ -> Nothing       _ -> Nothing   }@@ -157,20 +157,20 @@ ruleIntegerType1 = Rule   { name = "integer - TYPE 1"   , pattern =-    [ regex "(\xc601|\xc77c|\xc774|\xc0bc|\xc0ac|\xc624|\xc721|\xce60|\xd314|\xad6c)"+    [ regex "(영|일|이|삼|사|오|육|칠|팔|구)"     ]   , prod = \tokens -> case tokens of       (Token RegexMatch (GroupMatch (match:_)):_) -> case match of-        "\xc601" -> integer 0-        "\xc77c" -> integer 1-        "\xc774" -> integer 2-        "\xc0bc" -> integer 3-        "\xc0ac" -> integer 4-        "\xc624" -> integer 5-        "\xc721" -> integer 6-        "\xce60" -> integer 7-        "\xd314" -> integer 8-        "\xad6c" -> integer 9+        "영" -> integer 0+        "일" -> integer 1+        "이" -> integer 2+        "삼" -> integer 3+        "사" -> integer 4+        "오" -> integer 5+        "육" -> integer 6+        "칠" -> integer 7+        "팔" -> integer 8+        "구" -> integer 9         _ -> Nothing       _ -> Nothing   }@@ -179,16 +179,16 @@ ruleIntegerType1PowersOfTen = Rule   { name = "integer - TYPE 1: powers of ten"   , pattern =-    [ regex "(\xc2ed|\xbc31|\xcc9c|\xb9cc|\xc5b5|\xc870)"+    [ regex "(십|백|천|만|억|조)"     ]   , prod = \tokens -> case tokens of       (Token RegexMatch (GroupMatch (match:_)):_) -> case match of-        "\xc2ed" -> double 10   >>= withGrain 1  >>= withMultipliable-        "\xbc31" -> double 1e2  >>= withGrain 2  >>= withMultipliable-        "\xcc9c" -> double 1e3  >>= withGrain 3  >>= withMultipliable-        "\xb9cc" -> double 1e4  >>= withGrain 4  >>= withMultipliable-        "\xc5b5" -> double 1e8  >>= withGrain 8  >>= withMultipliable-        "\xc870" -> double 1e12 >>= withGrain 12 >>= withMultipliable+        "십" -> double 10   >>= withGrain 1  >>= withMultipliable+        "백" -> double 1e2  >>= withGrain 2  >>= withMultipliable+        "천" -> double 1e3  >>= withGrain 3  >>= withMultipliable+        "만" -> double 1e4  >>= withGrain 4  >>= withMultipliable+        "억" -> double 1e8  >>= withGrain 8  >>= withMultipliable+        "조" -> double 1e12 >>= withGrain 12 >>= withMultipliable         _ -> Nothing       _ -> Nothing   }@@ -224,19 +224,19 @@ ruleIntegerType2 = Rule   { name = "integer (1..10) - TYPE 2"   , pattern =-    [ regex "(\xd558\xb098|\xb458|\xc14b|\xb137|\xb2e4\xc12f|\xc5ec\xc12f|\xc77c\xacf1|\xc5ec\xb35f|\xc544\xd649)"+    [ regex "(하나|둘|셋|넷|다섯|여섯|일곱|여덟|아홉)"     ]   , prod = \tokens -> case tokens of       (Token RegexMatch (GroupMatch (match:_)):_) -> case match of-        "\xd558\xb098" -> integer 1-        "\xb458" -> integer 2-        "\xc14b" -> integer 3-        "\xb137" -> integer 4-        "\xb2e4\xc12f" -> integer 5-        "\xc5ec\xc12f" -> integer 6-        "\xc77c\xacf1" -> integer 7-        "\xc5ec\xb35f" -> integer 8-        "\xc544\xd649" -> integer 9+        "하나" -> integer 1+        "둘" -> integer 2+        "셋" -> integer 3+        "넷" -> integer 4+        "다섯" -> integer 5+        "여섯" -> integer 6+        "일곱" -> integer 7+        "여덟" -> integer 8+        "아홉" -> integer 9         _ -> Nothing       _ -> Nothing   }@@ -246,7 +246,7 @@   { name = "fraction"   , pattern =     [ dimension Numeral-    , regex "\xbd84(\xc758|\xc5d0)"+    , regex "분(의|에)"     , dimension Numeral     ]   , prod = \tokens -> case tokens of@@ -262,22 +262,22 @@   { name = "number dot number - 삼점사"   , pattern =     [ dimension Numeral-    , regex "(\xc810|\xca5c)((\xc601|\xc77c|\xc774|\xc0bc|\xc0ac|\xc624|\xc721|\xce60|\xd314|\xad6c)+)"+    , regex "(점|쩜)((영|일|이|삼|사|오|육|칠|팔|구)+)"     ]   , prod = \tokens -> case tokens of       (Token Numeral (NumeralData {TNumeral.value = v1}):        Token RegexMatch (GroupMatch (_:match:_)):        _) -> do-        let getDigit '\xc601' = Just "0"-            getDigit '\xc77c' = Just "1"-            getDigit '\xc774' = Just "2"-            getDigit '\xc0bc' = Just "3"-            getDigit '\xc0ac' = Just "4"-            getDigit '\xc624' = Just "5"-            getDigit '\xc721' = Just "6"-            getDigit '\xce60' = Just "7"-            getDigit '\xd314' = Just "8"-            getDigit '\xad6c' = Just "9"+        let getDigit '영' = Just "0"+            getDigit '일' = Just "1"+            getDigit '이' = Just "2"+            getDigit '삼' = Just "3"+            getDigit '사' = Just "4"+            getDigit '오' = Just "5"+            getDigit '육' = Just "6"+            getDigit '칠' = Just "7"+            getDigit '팔' = Just "8"+            getDigit '구' = Just "9"             getDigit _ = Nothing         v2 <- parseDouble . Text.concat . mapMaybe getDigit $ Text.unpack match         double $ v1 + decimalsToDouble v2

@@ -14,13 +14,13 @@ import Prelude import Data.String -import Duckling.Lang+import Duckling.Locale import Duckling.Numeral.Types import Duckling.Resolve import Duckling.Testing.Types  corpus :: Corpus-corpus = (testContext {lang = MY}, allExamples)+corpus = (testContext {locale = makeLocale MY Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -27,7 +27,7 @@   { name = "integer (11..99) "   , pattern =     [ numberBetween 1 10-    , regex "\x1006\x101a\x103a\x1037"+    , regex "ဆယ့်"     , numberBetween 1 10     ]   , prod = \tokens -> case tokens of@@ -42,20 +42,20 @@ ruleIntegerNumeric = Rule   { name = "integer (0..9) - numeric"   , pattern =-    [ regex "(\x1040|\x1041|\x1042|\x1043|\x1044|\x1045|\x1046|\x1047|\x1048|\x1049)"+    [ regex "(၀|၁|၂|၃|၄|၅|၆|၇|၈|၉)"     ]   , prod = \tokens -> case tokens of       (Token RegexMatch (GroupMatch (match:_)):_) -> case match of-        "\x1040" -> integer 0-        "\x1041" -> integer 1-        "\x1042" -> integer 2-        "\x1043" -> integer 3-        "\x1044" -> integer 4-        "\x1045" -> integer 5-        "\x1046" -> integer 6-        "\x1047" -> integer 7-        "\x1048" -> integer 8-        "\x1049" -> integer 9+        "၀" -> integer 0+        "၁" -> integer 1+        "၂" -> integer 2+        "၃" -> integer 3+        "၄" -> integer 4+        "၅" -> integer 5+        "၆" -> integer 6+        "၇" -> integer 7+        "၈" -> integer 8+        "၉" -> integer 9         _ -> Nothing       _ -> Nothing   }@@ -64,7 +64,7 @@ ruleInteger3 = Rule   { name = "integer (11..19) "   , pattern =-    [ regex "\x1006\x101a\x103a\x1037"+    [ regex "ဆယ့်"     , numberBetween 1 10     ]   , prod = \tokens -> case tokens of@@ -76,13 +76,13 @@ ruleIntegerPali = Rule   { name = "integer (1..3) - pali"   , pattern =-    [ regex "(\x1015\x1011\x1019|\x1012\x102f\x1010\x102d\x101a|\x1010\x1010\x102d\x101a)"+    [ regex "(ပထမ|ဒုတိယ|တတိယ)"     ]   , prod = \tokens -> case tokens of       (Token RegexMatch (GroupMatch (match:_)):_) -> case match of-        "\x1015\x1011\x1019" -> integer 1-        "\x1012\x102f\x1010\x102d\x101a" -> integer 2-        "\x1010\x1010\x102d\x101a" -> integer 3+        "ပထမ" -> integer 1+        "ဒုတိယ" -> integer 2+        "တတိယ" -> integer 3         _ -> Nothing       _ -> Nothing   }@@ -92,7 +92,7 @@   { name = "integer (100..900)"   , pattern =     [ numberBetween 1 10-    , regex "\x101b\x102c"+    , regex "ရာ"     ]   , prod = \tokens -> case tokens of       (Token Numeral (NumeralData {TNumeral.value = v}):_) -> double $ v * 100@@ -104,7 +104,7 @@   { name = "integer (1000..9000)"   , pattern =     [ numberBetween 1 10-    , regex "\x1011\x1031\x102c\x1004\x103a"+    , regex "ထောင်"     ]   , prod = \tokens -> case tokens of       (Token Numeral (NumeralData {TNumeral.value = v}):_) -> double $ v * 1000@@ -116,7 +116,7 @@   { name = "integer (10000..90000)"   , pattern =     [ numberBetween 1 10-    , regex "\x101e\x1031\x102c\x1004\x103a\x1038"+    , regex "သောင်း"     ]   , prod = \tokens -> case tokens of       (Token Numeral (NumeralData {TNumeral.value = v}):_) -> double $ v * 10000@@ -127,7 +127,7 @@ ruleInteger = Rule   { name = "integer 0"   , pattern =-    [ regex "\x101e\x102f\x1036\x100a|\x1019\x101b\x103e\x102d"+    [ regex "သုံည|မရှိ"     ]   , prod = \_ -> integer 0   }@@ -137,7 +137,7 @@   { name = "integer (10..90)"   , pattern =     [ numberBetween 1 10-    , regex "\x1006\x101a\x103a"+    , regex "ဆယ်"     ]   , prod = \tokens -> case tokens of       (Token Numeral (NumeralData {TNumeral.value = v}):_) -> double $ v * 10@@ -148,20 +148,20 @@ ruleInteger2 = Rule   { name = "integer (1..10)"   , pattern =-    [ regex "(\x1010\x1005\x103a|\x1014\x103e\x1005\x103a|\x101e\x102f\x1036\x1038|\x101c\x1031\x1038|\x1004\x102b\x1038|\x1001\x103c\x1031\x102b\x1000\x103a|\x1001\x102f\x1014\x103e\x1005\x103a|\x101b\x103e\x1005\x103a|\x1000\x102d\x102f\x1038|\x1010\x1005\x103a\x1006\x101a\x103a)"+    [ regex "(တစ်|နှစ်|သုံး|လေး|ငါး|ခြေါက်|ခုနှစ်|ရှစ်|ကိုး|တစ်ဆယ်)"     ]   , prod = \tokens -> case tokens of       (Token RegexMatch (GroupMatch (match:_)):_) -> case match of-        "\x1010\x1005\x103a" -> integer 1-        "\x1014\x103e\x1005\x103a" -> integer 2-        "\x101e\x102f\x1036\x1038" -> integer 3-        "\x101c\x1031\x1038" -> integer 4-        "\x1004\x102b\x1038" -> integer 5-        "\x1001\x103c\x1031\x102b\x1000\x103a" -> integer 6-        "\x1001\x102f\x1014\x103e\x1005\x103a" -> integer 7-        "\x101b\x103e\x1005\x103a" -> integer 8-        "\x1000\x102d\x102f\x1038" -> integer 9-        "\x1010\x1005\x103a\x1006\x101a\x103a" -> integer 10+        "တစ်" -> integer 1+        "နှစ်" -> integer 2+        "သုံး" -> integer 3+        "လေး" -> integer 4+        "ငါး" -> integer 5+        "ခြေါက်" -> integer 6+        "ခုနှစ်" -> integer 7+        "ရှစ်" -> integer 8+        "ကိုး" -> integer 9+        "တစ်ဆယ်" -> integer 10         _ -> Nothing       _ -> Nothing   }

@@ -14,13 +14,13 @@ import Prelude import Data.String -import Duckling.Lang+import Duckling.Locale import Duckling.Numeral.Types import Duckling.Resolve import Duckling.Testing.Types  corpus :: Corpus-corpus = (testContext {lang = NB}, allExamples)+corpus = (testContext {locale = makeLocale NB Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -72,7 +72,7 @@ ruleFew = Rule   { name = "few"   , pattern =-    [ regex "(noen )?f\x00e5"+    [ regex "(noen )?få"     ]   , prod = \_ -> integer 3   }@@ -158,7 +158,7 @@   { name = "numbers suffixes (K, M, G)"   , pattern =     [ dimension Numeral-    , regex "([kmg])(?=[\\W\\$\x20ac]|$)"+    , regex "([kmg])(?=[\\W\\$€]|$)"     ]   , prod = \tokens -> case tokens of       (Token Numeral (NumeralData {TNumeral.value = v}):@@ -214,7 +214,7 @@   , ( "intet" , 0 )   , ( "en" , 1 )   , ( "ett" , 1 )-  , ( "\x00e9n" , 1 )+  , ( "én" , 1 )   , ( "to" , 2 )   , ( "tre" , 3 )   , ( "fire" , 4 )@@ -231,7 +231,7 @@   , ( "fjorten" , 14 )   , ( "femten" , 15 )   , ( "seksten" , 16 )-  , ( "s\x00f8tten" , 17 )+  , ( "søtten" , 17 )   , ( "sytten" , 17 )   , ( "atten" , 18 )   , ( "nitten" , 19 )@@ -241,7 +241,7 @@ ruleInteger = Rule   { name = "integer (0..19)"   , pattern =-    [ regex "(intet|ingen|null|en|ett|\x00e9n|to|tretten|tre|fire|femten|fem|seksten|seks|syv|sju|\x00e5tte|nitten|ni|ti|elleve|tolv|fjorten|sytten|s\x00f8tten|atten)"+    [ regex "(intet|ingen|null|en|ett|én|to|tretten|tre|fire|femten|fem|seksten|seks|syv|sju|åtte|nitten|ni|ti|elleve|tolv|fjorten|sytten|søtten|atten)"     ]   , prod = \tokens -> case tokens of       (Token RegexMatch (GroupMatch (match:_)):_) ->@@ -255,12 +255,12 @@   , ( "tjue" , 20 )   , ( "tredve" , 30 )   , ( "tretti" , 30 )-  , ( "f\x00f8rti" , 40 )+  , ( "førti" , 40 )   , ( "femti" , 50 )   , ( "seksti" , 60 )   , ( "sytti" , 70 )-  , ( "s\x00f8tti" , 70 )-  , ( "\x00e5tti" , 80 )+  , ( "søtti" , 70 )+  , ( "åtti" , 80 )   , ( "nitti" , 90 )   ] @@ -268,7 +268,7 @@ ruleInteger2 = Rule   { name = "integer (20..90)"   , pattern =-    [ regex "(tyve|tjue|tredve|tretti|f\x00f8rti|femti|seksti|sytti|s\x00f8tti|\x00e5tti|nitti)"+    [ regex "(tyve|tjue|tredve|tretti|førti|femti|seksti|sytti|søtti|åtti|nitti)"     ]   , prod = \tokens -> case tokens of       (Token RegexMatch (GroupMatch (match:_)):_) ->

@@ -14,13 +14,13 @@ import Prelude import Data.String -import Duckling.Lang+import Duckling.Locale import Duckling.Numeral.Types import Duckling.Resolve import Duckling.Testing.Types  corpus :: Corpus-corpus = (testContext {lang = NL}, allExamples)+corpus = (testContext {locale = makeLocale NL Nothing}, allExamples)  allExamples :: [Example] allExamples = concat@@ -47,6 +47,10 @@              , "drie en dertig"              , "0033"              ]+  , examples (NumeralValue 12)+             [ "twaalf"+             , "dozijn"+             ]   , examples (NumeralValue 14)              [ "14"              , "veertien"@@ -79,6 +83,9 @@   , examples (NumeralValue 5000)              [ "5 duizend"              , "vijf duizend"+             ]+  , examples (NumeralValue 144)+             [ "gros"              ]   , examples (NumeralValue 122)              [ "honderd tweeëntwintig"

@@ -102,7 +102,7 @@ ruleInteger3 = Rule   { name = "integer ([2-9][1-9])"   , pattern =-    [ regex "(een|twee|drie|vier|vijf|zes|zeven|acht|negen)(?:e|\x00eb)n(twintig|dertig|veertig|vijftig|zestig|zeventig|tachtig|negentig)"+    [ regex "(een|twee|drie|vier|vijf|zes|zeven|acht|negen)(?:e|ë)n(twintig|dertig|veertig|vijftig|zestig|zeventig|tachtig|negentig)"     ]   , prod = \tokens -> case tokens of       (Token RegexMatch (GroupMatch (m1:m2:_)):_) -> do@@ -143,7 +143,7 @@   { name = "numbers suffixes (K, M, G)"   , pattern =     [ dimension Numeral-    , regex "([kmg])(?=[\\W\\$\x20ac]|$)"+    , regex "([kmg])(?=[\\W\\$€]|$)"     ]   , prod = \tokens -> case tokens of       (Token Numeral (NumeralData {TNumeral.value = v}):@@ -205,12 +205,21 @@   , prod = \_ -> integer 12 >>= withGrain 1   } +ruleGross :: Rule+ruleGross = Rule+  { name = "gros"+  , pattern =+    [ regex "gros"+    ]+  , prod = \_ -> integer 144 >>= withGrain 1+  }+ zeroNineteenMap :: HashMap Text Integer zeroNineteenMap = HashMap.fromList   [ ("niks", 0)   , ("nul", 0)   , ("geen", 0)-  , ("\x00e9\x00e9n", 1)+  , ("één", 1)   , ("een", 1)   , ("twee", 2)   , ("drie", 3)@@ -236,7 +245,7 @@ ruleInteger = Rule   { name = "integer (0..19)"   , pattern =-    [ regex "(geen|nul|niks|een|\x00e9\x00e9n|twee|drie|vier|vijftien|vijf|zestien|zes|zeventien|zeven|achtien|acht|negentien|negen|tien|elf|twaalf|dertien|veertien)"+    [ regex "(geen|nul|niks|een|één|twee|drie|vier|vijftien|vijf|zestien|zes|zeventien|zeven|achtien|acht|negentien|negen|tien|elf|twaalf|dertien|veertien)"     ]   , prod = \tokens -> case tokens of       (Token RegexMatch (GroupMatch (match:_)):_) ->@@ -274,6 +283,7 @@   , ruleDecimalNumeral   , ruleDecimalWithThousandsSeparator   , ruleDozen+  , ruleGross   , ruleFew   , ruleInteger   , ruleInteger2

@@ -14,13 +14,13 @@ import Prelude import Data.String -import Duckling.Lang+import Duckling.Locale import Duckling.Numeral.Types import Duckling.Resolve import Duckling.Testing.Types  corpus :: Corpus-corpus = (testContext {lang = PL}, allExamples)+corpus = (testContext {locale = makeLocale PL Nothing}, allExamples)  allExamples :: [Example] allExamples = concat

@@ -28,7 +28,7 @@ ruleSixteen = Rule   { name = "sixteen"   , pattern =-    [ regex "szesna(s|\x015b)(tu|cie|toma)"+    [ regex "szesna(s|ś)(tu|cie|toma)"     ]   , prod = \_ -> integer 16   }@@ -37,7 +37,7 @@ ruleFourteen = Rule   { name = "fourteen"   , pattern =-    [ regex "czterna(s|\x015b)(tu|cie|toma)"+    [ regex "czterna(s|ś)(tu|cie|toma)"     ]   , prod = \_ -> integer 14   }@@ -46,7 +46,7 @@ ruleTwo = Rule   { name = "two"   , pattern =-    [ regex "dw(a|(o|\x00f3)(ch|m)|oma|iema|ie)"+    [ regex "dw(a|(o|ó)(ch|m)|oma|iema|ie)"     ]   , prod = \_ -> integer 2   }@@ -55,7 +55,7 @@ ruleSixty = Rule   { name = "sixty"   , pattern =-    [ regex "sze(\x015b\x0107)dziesi(\x0105)t|sze(\x015b\x0107)dziesi(\x0119)ci(u|oma)"+    [ regex "sze(ść)dziesi(ą)t|sze(ść)dziesi(ę)ci(u|oma)"     ]   , prod = \_ -> integer 60   }@@ -92,7 +92,7 @@ ruleOne = Rule   { name = "one"   , pattern =-    [ regex "jed(en|nego|nemu|nym|nej|n(a|\x0105))"+    [ regex "jed(en|nego|nemu|nym|nej|n(a|ą))"     ]   , prod = \_ -> integer 1   }@@ -114,7 +114,7 @@ ruleTen = Rule   { name = "ten"   , pattern =-    [ regex "dzisi(e|\x0119)(\x0107|c)(iu|ioma)?"+    [ regex "dzisi(e|ę)(ć|c)(iu|ioma)?"     ]   , prod = \_ -> integer 10   }@@ -149,7 +149,7 @@ ruleNine = Rule   { name = "nine"   , pattern =-    [ regex "dziewi(e|\x0119)(\x0107|c)(iu|ioma)?"+    [ regex "dziewi(e|ę)(ć|c)(iu|ioma)?"     ]   , prod = \_ -> integer 9   }@@ -167,7 +167,7 @@ ruleTwelve = Rule   { name = "twelve"   , pattern =-    [ regex "dwunast(u|oma)|dwana(\x015b|s)cie"+    [ regex "dwunast(u|oma)|dwana(ś|s)cie"     ]   , prod = \_ -> integer 12   }@@ -187,7 +187,7 @@ ruleFifteen = Rule   { name = "fifteen"   , pattern =-    [ regex "pi(\x0119)tna(s|\x015b)(ta|tu|cie|toma)"+    [ regex "pi(ę)tna(s|ś)(ta|tu|cie|toma)"     ]   , prod = \_ -> integer 15   }@@ -196,7 +196,7 @@ ruleEleven = Rule   { name = "eleven"   , pattern =-    [ regex "jedena(stu|(s|\x015b)cie|stoma)"+    [ regex "jedena(stu|(s|ś)cie|stoma)"     ]   , prod = \_ -> integer 11   }@@ -205,7 +205,7 @@ ruleThirteen = Rule   { name = "thirteen"   , pattern =-    [ regex "trzyna(\x015b|s)(tu|cie|toma)"+    [ regex "trzyna(ś|s)(tu|cie|toma)"     ]   , prod = \_ -> integer 13   }@@ -214,7 +214,7 @@ ruleThirty = Rule   { name = "thirty"   , pattern =-    [ regex "trzydzie(\x015b)ci|trzydziest(u|oma)"+    [ regex "trzydzie(ś)ci|trzydziest(u|oma)"     ]   , prod = \_ -> integer 30   }@@ -223,7 +223,7 @@ ruleNumeral2 = Rule   { name = "number 200"   , pattern =-    [ regex "dwie((\x015b)cie| setki)"+    [ regex "dwie((ś)cie| setki)"     ]   , prod = \_ -> integer 200 >>= withGrain 2   }@@ -232,7 +232,7 @@ ruleSeventeen = Rule   { name = "seventeen"   , pattern =-    [ regex "siedemna(s|\x015b)(tu|cie|toma)"+    [ regex "siedemna(s|ś)(tu|cie|toma)"     ]   , prod = \_ -> integer 17   }@@ -250,7 +250,7 @@ ruleNumeral9 = Rule   { name = "number 900"   , pattern =-    [ regex "dziewi(\x0119\x0107)(set| setek)"+    [ regex "dziewi(ęć)(set| setek)"     ]   , prod = \_ -> integer 900 >>= withGrain 2   }@@ -268,7 +268,7 @@ ruleTwenty = Rule   { name = "twenty"   , pattern =-    [ regex "dwadzie(\x015b|s)cia|dwudziest(u|oma)"+    [ regex "dwadzie(ś|s)cia|dwudziest(u|oma)"     ]   , prod = \_ -> integer 20   }@@ -286,7 +286,7 @@ ruleEight = Rule   { name = "eight"   , pattern =-    [ regex "o(s|\x015b)(iem|miu|mioma)"+    [ regex "o(s|ś)(iem|miu|mioma)"     ]   , prod = \_ -> integer 8   }@@ -295,7 +295,7 @@ ruleNumeral5 = Rule   { name = "number 500"   , pattern =-    [ regex "pi(\x0119\x0107)(set| setek)"+    [ regex "pi(ęć)(set| setek)"     ]   , prod = \_ -> integer 500 >>= withGrain 2   }@@ -322,7 +322,7 @@ ruleThousand = Rule   { name = "thousand"   , pattern =-    [ regex "ty(s|\x015b)i(a|\x0105|\x0119)c(e|y)?"+    [ regex "ty(s|ś)i(a|ą|ę)c(e|y)?"     ]   , prod = \_ -> integer 1000 >>= withGrain 3 >>= withMultipliable   }@@ -331,7 +331,7 @@ ruleMillion = Rule   { name = "million"   , pattern =-    [ regex "milion(y|(\x00f3)w)?"+    [ regex "milion(y|(ó)w)?"     ]   , prod = \_ -> integer 1000000 >>= withGrain 6 >>= withMultipliable   }@@ -385,7 +385,7 @@   { name = "numbers suffixes (K, M, G)"   , pattern =     [ dimension Numeral-    , regex "([kmg])(?=[\\W\\$\x20ac]|$)"+    , regex "([kmg])(?=[\\W\\$€]|$)"     ]   , prod = \tokens -> case tokens of       (Token Numeral (NumeralData {TNumeral.value = v}):@@ -429,7 +429,7 @@ ruleSix = Rule   { name = "six"   , pattern =-    [ regex "sze(s|\x015b)(c|\x0107)(iu|oma|u)?"+    [ regex "sze(s|ś)(c|ć)(iu|oma|u)?"     ]   , prod = \_ -> integer 6   }@@ -438,7 +438,7 @@ ruleNumeral6 = Rule   { name = "number 600"   , pattern =-    [ regex "(sze\x015b\x0107(set| setek))"+    [ regex "(sześć(set| setek))"     ]   , prod = \_ -> integer 600 >>= withGrain 2   }@@ -456,7 +456,7 @@ ruleFive = Rule   { name = "five"   , pattern =-    [ regex "pi(e|\x0119)(c|\x0107)(iu|oma|u)?"+    [ regex "pi(e|ę)(c|ć)(iu|oma|u)?"     ]   , prod = \_ -> integer 5   }@@ -465,7 +465,7 @@ ruleFourty = Rule   { name = "fou?rty"   , pattern =-    [ regex "czterdzie(\x015b)ci|czterdziest(u|oma)"+    [ regex "czterdzie(ś)ci|czterdziest(u|oma)"     ]   , prod = \_ -> integer 40   }@@ -492,7 +492,7 @@ ruleNineteen = Rule   { name = "nineteen"   , pattern =-    [ regex "dziewietna(s|\x015b)(tu|cie|toma)"+    [ regex "dziewietna(s|ś)(tu|cie|toma)"     ]   , prod = \_ -> integer 19   }@@ -515,7 +515,7 @@ ruleEighteen = Rule   { name = "eighteen"   , pattern =-    [ regex "osiemna(s|\x015b)(tu|cie|toma)"+    [ regex "osiemna(s|ś)(tu|cie|toma)"     ]   , prod = \_ -> integer 18   }@@ -550,7 +550,7 @@ ruleFifty = Rule   { name = "fifty"   , pattern =-    [ regex "pi(\x0119\x0107)dziesi(\x0105)t|pi(\x0119\x0107)dziesi(\x0119)ci(u|oma)"+    [ regex "pi(ęć)dziesi(ą)t|pi(ęć)dziesi(ę)ci(u|oma)"     ]   , prod = \_ -> integer 50   }