Add missing copyright header + auto-format NumParser.hs

Summary: as title

Reviewed By: yuzh174

Differential Revision: D39996261

fbshipit-source-id: 33902b34db68daefc48c03878b8686236ac9ded3

Duckling/Numeral/DE/NumParser.hs

@@ -1,17 +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.
 {-# LANGUAGE DeriveFunctor #-}
 
 module Duckling.Numeral.DE.NumParser (parseNumeral) where
 
-import Prelude
 import Control.Applicative
 import Data.Char
-import Data.List
 import Data.Foldable
+import Data.List
 import Data.String
+import Prelude
 
-newtype Parser a
+newtype Parser a = Parser {runParser :: String -> Maybe (a, String)}
-  = Parser { runParser :: String -> Maybe (a, String) }
+  deriving (Functor)
-  deriving Functor
 
 char :: Char -> Parser Char
 char c = Parser p
@@ -41,6 +45,7 @@ p .+. p' = (+) <$> p <*> p'
 p .*. p' = (*) <$> p <*> p'
 
 infixl 6 .+.
+
 infixl 7 .*.
 
 opt :: NumParser -> NumParser
@@ -48,16 +53,21 @@ opt p = p <|> Parser p'
   where
     p' s = Just (0, s)
 
-data NumItem = NumItem { base    :: NumParser
+data NumItem = NumItem
+  { base :: NumParser
   , plus10 :: NumParser
   , times10 :: [NumParser]
   }
 
 defaultNumItem :: Integer -> String -> NumItem
-defaultNumItem value form = NumItem { base    = p
+defaultNumItem value form =
+  NumItem
+    { base = p
     , plus10 = p .+. ten
     , times10 = [p .*. ty]
-                                    } where p = assign value form
+    }
+  where
+    p = assign value form
 
 type Assignment = Integer -> String -> NumParser
 
@@ -80,15 +90,27 @@ und :: NumParser
 und = assign 0 "und"
 
 one :: NumItem
-one = (defaultNumItem 1 "ein") { plus10  = assign 11 "elf"
+one =
-                               , times10 = [ ten ] }
+  (defaultNumItem 1 "ein")
+    { plus10 = assign 11 "elf"
+    , times10 = [ten]
+    }
 
 two :: NumItem
-two = (defaultNumItem 2 "zwei") { plus10  = assign 12 "zwölf"
+two =
-                                , times10 = [ assign 20 "zwanzig" ] }
+  (defaultNumItem 2 "zwei")
+    { plus10 = assign 12 "zwölf"
+    , times10 = [assign 20 "zwanzig"]
+    }
+
 three :: NumItem
-three = (defaultNumItem 3 "drei") { times10 = [ assign 30 "dreißig"
+three =
-                                              , assign 30 "dreissig" ] }
+  (defaultNumItem 3 "drei")
+    { times10 =
+        [ assign 30 "dreißig"
+        , assign 30 "dreissig"
+        ]
+    }
 
 four :: NumItem
 four = defaultNumItem 4 "vier"
@@ -97,12 +119,18 @@ five :: NumItem
 five = defaultNumItem 5 "fünf"
 
 six :: NumItem
-six = (defaultNumItem 6 "sechs") { plus10  = assign 16 "sechzehn"
+six =
-                                 , times10 = [ assign 60 "sechzig" ] }
+  (defaultNumItem 6 "sechs")
+    { plus10 = assign 16 "sechzehn"
+    , times10 = [assign 60 "sechzig"]
+    }
 
 seven :: NumItem
-seven = (defaultNumItem 7 "sieben") { plus10  = assign 17 "siebzehn"
+seven =
-                                    , times10 = [ assign 70 "siebzig" ] }
+  (defaultNumItem 7 "sieben")
+    { plus10 = assign 17 "siebzehn"
+    , times10 = [assign 70 "siebzig"]
+    }
 
 eight :: NumItem
 eight = defaultNumItem 8 "acht"
@@ -120,7 +148,8 @@ tensFrom20 :: NumParser
 tensFrom20 = asum (concatMap times10 (tail digitLexicon))
 
 from1to99 :: NumParser
-from1to99 = opt (from1to9 .+. und) .+. tensFrom20
+from1to99 =
+  opt (from1to9 .+. und) .+. tensFrom20
     <|> foldr ((<|>) . plus10) empty digitLexicon
     <|> ten
     <|> from1to9
@@ -135,17 +164,19 @@ from1to999999' :: NumParser
 from1to999999' = Parser p
   where
     p s
-      | isPrefixOf "hundert" s || isPrefixOf "tausend" s
+      | isPrefixOf "hundert" s || isPrefixOf "tausend" s =
-        = runParser from1to999999 ("ein" ++ s)
+        runParser from1to999999 ("ein" ++ s)
-      | otherwise
+      | otherwise =
-        = runParser from1to999999 s
+        runParser from1to999999 s
 
 fromYear1100to1999 :: NumParser
-fromYear1100to1999 = asum ((\n -> plus10 n .*. hundred) <$> digitLexicon)
+fromYear1100to1999 =
+  asum ((\n -> plus10 n .*. hundred) <$> digitLexicon)
     .+. opt (opt und .+. from1to99)
 
 allNumerals :: NumParser
-allNumerals = fromYear1100to1999
+allNumerals =
+  fromYear1100to1999
     <|> from1to999999'
 
 removeInflection :: (Integer, String) -> Maybe Integer