Parse formatted number string to number

src/FormatNumber.elm

@@ -1,4 +1,7 @@
-module FormatNumber exposing (format)
+module FormatNumber exposing
+    ( format
+    , parse
+    )
 
 {-| This simple package formats `Float` numbers as pretty strings. It is
 flexible enough to deal with different number of decimals, different thousand
@@ -22,7 +25,7 @@ Just convert them to `Float` before passing them to `format`:
 -}
 
 import FormatNumber.Locales as Locales
-import FormatNumber.Parser exposing (parse)
+import FormatNumber.Parser as Parser
 import FormatNumber.Stringfy exposing (stringfy)
 
 
@@ -139,5 +142,30 @@ import FormatNumber.Stringfy exposing (stringfy)
 format : Locales.Locale -> Float -> String
 format locale number_ =
     number_
-        |> parse locale
+        |> Parser.parse locale
         |> stringfy locale
+
+
+{-| Parses a pretty string into `Maybe Float`:
+
+    import FormatNumber.Locales exposing (Decimals(..), Locale, base, frenchLocale, spanishLocale, usLocale)
+
+    parse { base | thousandSeparator = "," } "100,000.345"
+    --> Just 100000.345
+
+    parse { base | thousandSeparator = ",", negativePrefix = "-" } "-100#000"
+    --> Just -100000
+
+    parse { base | negativePrefix = "", negativeSuffix = "-" } "100,000-"
+    --> Just -100000
+
+    parse { base | negativePrefix = " ~", negativeSuffix = "" } " ~100,000"
+    --> Just -100000
+
+    parse { base | thousandSeparator = ",", negativePrefix = "(", negativeSuffix = ")" } "(100,000.546)"
+    --> Just -100000.546
+
+-}
+parse : Locales.Locale -> String -> Maybe Float
+parse locale str =
+    Parser.parseString locale str

src/FormatNumber/Parser.elm

@@ -4,13 +4,15 @@ module FormatNumber.Parser exposing
     , addZerosToFit
     , classify
     , parse
+    , parseString
     , removeZeros
     , splitInParts
     , splitThousands
     )
 
 import Char
 import FormatNumber.Locales exposing (Decimals(..), Locale)
+import Regex
 import Round
 import String
 
@@ -378,3 +380,61 @@ parse locale original =
                 | prefix = locale.zeroPrefix
                 , suffix = locale.zeroSuffix
             }
+
+
+{-| Given a `Locale` parses a `String` into a `Maybe Float`
+-}
+parseString : Locale -> String -> Maybe Float
+parseString locale value =
+    let
+        isNegative : Bool
+        isNegative =
+            negativePrefixMatch && negativeSuffixMatch
+
+        negativePrefixMatch : Bool
+        negativePrefixMatch =
+            value
+                |> String.startsWith locale.negativePrefix
+
+        negativeSuffixMatch : Bool
+        negativeSuffixMatch =
+            value
+                |> String.endsWith locale.negativeSuffix
+
+        chrs : Regex.Regex
+        chrs =
+            "[^\\d]"
+                |> Regex.fromString
+                |> Maybe.withDefault Regex.never
+
+        splitValue : String -> List String
+        splitValue nbr =
+            nbr
+                |> String.split locale.decimalSeparator
+                |> List.map (Regex.replace chrs (\_ -> ""))
+
+        sumNumber : Float -> Float -> Float -> Float
+        sumNumber i d pow =
+            if isNegative then
+                -1 * (i + d / (10 ^ pow))
+
+            else
+                i + d / (10 ^ pow)
+    in
+    case splitValue value of
+        integer :: decimal :: [] ->
+            Maybe.map3 sumNumber (String.toFloat integer) (String.toFloat decimal) (Just (toFloat (String.length decimal)))
+
+        integer :: [] ->
+            Maybe.map
+                (\n ->
+                    if isNegative then
+                        -1 * n
+
+                    else
+                        n
+                )
+                (String.toFloat integer)
+
+        _ ->
+            Nothing