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,33 @@ 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 | 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

@@ -3,14 +3,17 @@ module FormatNumber.Parser exposing
     , FormattedNumber
     , addZerosToFit
     , classify
+    , joinParts
     , parse
+    , parseString
     , removeZeros
     , splitInParts
     , splitThousands
     )
 
 import Char
 import FormatNumber.Locales exposing (Decimals(..), Locale)
+import Regex
 import Round
 import String
 
@@ -211,6 +214,67 @@ getDecimals locale digits =
             addZerosToFit min digits
 
 
+
+{- Joins parts into `Maybe Float`. It expects parts to be strings with only digits.
+
+   joinParts ("100", "235")
+   --> Just 100.235
+
+   joinParts ("", "534")
+   --> Just 0.534
+
+   joinParts ("243", "")
+   --> Just 243
+
+   joinParts ("", "")
+   --> Nothing
+
+   joinParts ("100,00", "243")
+   --> Nothing
+
+   joinParts ("10000", "24,3")
+   --> Nothing
+
+-}
+
+
+joinParts : ( String, String ) -> Maybe Float
+joinParts parts =
+    let
+        decimalCount : Float
+        decimalCount =
+            parts
+                |> Tuple.second
+                |> String.length
+                |> toFloat
+
+        integers : Maybe Float
+        integers =
+            parts
+                |> Tuple.first
+                |> String.toFloat
+
+        decimalValue : Maybe Float
+        decimalValue =
+            parts
+                |> Tuple.second
+                |> String.toFloat
+                |> Maybe.map (\n -> n / (10 ^ decimalCount))
+    in
+    case parts of
+        ( "", "" ) ->
+            Nothing
+
+        ( _, "" ) ->
+            integers
+
+        ( "", _ ) ->
+            decimalValue
+
+        _ ->
+            Maybe.map2 (+) integers decimalValue
+
+
 {-| Given a `Locale` parses a `Float` into a `FormattedNumber`:
 
     import FormatNumber.Locales exposing (Decimals(..), usLocale)
@@ -378,3 +442,54 @@ 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 =
+            String.startsWith locale.negativePrefix value
+                && String.endsWith
+                    locale.negativeSuffix
+                    value
+
+        notDigits : Regex.Regex
+        notDigits =
+            "\\D"
+                |> Regex.fromString
+                |> Maybe.withDefault Regex.never
+
+        onlyDigits : String -> String
+        onlyDigits = 
+            Regex.replace notDigits (\_ -> "")
+
+        splitValue : String -> List String
+        splitValue number =
+            number
+                |> String.split locale.decimalSeparator
+                |> List.map onlyDigits
+    in
+    case splitValue value of
+        integers :: decimals :: [] ->
+            if isNegative then
+                ( integers, decimals )
+                    |> joinParts
+                    |> Maybe.map (negate)
+
+            else
+                joinParts ( integers, decimals )
+
+        integers :: [] ->
+            if isNegative then
+                ( integers, "" )
+                    |> joinParts
+                    |> Maybe.map (negate)
+
+            else
+                joinParts ( integers, "" )
+
+        _ ->
+            Nothing