Merge pull request #147 from chr1st0scli/parse-number-culture

Parse number culture

Author: chr1st0scli

CHANGELOG.md

@@ -16,6 +16,11 @@ Semantic versioning is followed.
 
 ### Removed
 
+## [1.3.0] - 2024-06-30
+
+### Added
+- `parse-number-culture` primitive procedure. #146
+
 ## [1.2.0] - 2024-02-18
 
 ### Added

README.md

@@ -10,7 +10,7 @@ RainLisp is a programming language, belonging to the LISP family of languages, w
 
 It is not intended to replace your everyday programming language at work. Though, you can integrate it with your existing systems to allow for their configuration in terms of code.
 
-For example, one can build a system where parts of its computations or workflow logic is implemented in RainLisp. Its simplicity and capabilites make it ideal for using it like a DSL (Domain Specific Language) that integrates with your .NET system.
+For example, one can build a system where parts of its computations or workflow logic is implemented in RainLisp. Its simplicity and capabilities make it ideal for using it like a DSL (Domain Specific Language) that integrates with your .NET system.
 
 Additionally, you can easily extend it to implement your own LISP dialect or replace some of its components, like the tokenizer and parser, and reuse the evaluator to easily build an entirely different but compatible programming language.
 

RainLisp/Docs/primitives.md

@@ -48,6 +48,7 @@
 - [pair?](primitives/is-pair.md)
 - [parse-datetime](primitives/parse-datetime.md)
 - [parse-number](primitives/parse-number.md)
+- [parse-number-culture](primitives/parse-number-culture.md)
 - [replace-string](primitives/replace-string.md)
 - [round](primitives/round.md)
 - [second](primitives/second.md)

RainLisp/Docs/primitives/parse-number-culture.md

@@ -0,0 +1,21 @@
+# parse-number-culture
+```scheme
+(parse-number-culture str culture)
+```
+Converts a string representation of a numeric value in a culture-specific format to its number equivalent.
+
+> *str* is the string containing the numeric info.
+
+> *culture* is a string specifying the culture name. If the culture name is an empty string, the [invariant](https://learn.microsoft.com/en-us/dotnet/api/system.globalization.cultureinfo.invariantculture) culture is used.
+For a list of valid names, look at the "*Language tag*" column of the [language table](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-lcid/a9eac961-e77d-41a6-90a5-ce1a8b0cdb9c).
+
+## Examples
+```scheme
+(parse-number-culture "2345.6789" "en-EN")
+```
+-> *2345.6789*
+
+```scheme
+(parse-number-culture "2345,6789" "el-GR")
+```
+-> *2345.6789*

RainLisp/Docs/quick-start/numbers.md

@@ -56,6 +56,7 @@ The operations that relate to numbers are:
 - [floor](../primitives/floor.md)
 - [number-to-string](../primitives/number-to-string.md)
 - [parse-number](../primitives/parse-number.md)
+- [parse-number-culture](../primitives/parse-number-culture.md)
 - [round](../primitives/round.md)
 
 Next, let's learn about [booleans](booleans.md).

RainLisp/Evaluation/PrimitiveOperation.cs

@@ -717,6 +717,17 @@ public static EvaluationResult NumberToString(EvaluationResult[]? values)
         public static EvaluationResult ParseNumber(EvaluationResult[]? values)
             => ApplyUnaryOperator(AsString, val => ValueOrThrowInvalid(() => new NumberDatum(double.Parse(val, CultureInfo.InvariantCulture))), values);
 
+        /// <summary>
+        /// Converts a string representation of a numeric value in a culture-specific format to its number equivalent.
+        /// </summary>
+        /// <param name="values">A string containing the numeric info, a string specifying the culture name. If the culture name is an empty string, the invariant culture is used.</param>
+        /// <returns>The equivalent numeric value.</returns>
+        /// <exception cref="WrongNumberOfArgumentsException">The given arguments are not two.</exception>
+        /// <exception cref="WrongTypeOfArgumentException">Not all arguments are string values.</exception>
+        /// <exception cref="InvalidValueException">The string value does not represent a number in a valid format for the specified culture or the culture is not found.</exception>
+        public static EvaluationResult ParseNumberCulture(EvaluationResult[]? values)
+            => ApplyBinaryOperator(AsString, (val, cult) => ValueOrThrowInvalid(() => new NumberDatum(double.Parse(val, new CultureInfo(cult, false)))), values);
+
         /// <summary>
         /// Rounds a numeric value to a specified number of fractional digits, using the away from zero rounding convention.
         /// </summary>

RainLisp/Grammar/Primitives.cs

@@ -315,6 +315,11 @@ public static class Primitives
         /// </summary>
         public const string PARSE_NUMBER = "parse-number";
 
+        /// <summary>
+        /// Converts a string representation of a numeric value in a culture-specific format to its number equivalent.
+        /// </summary>
+        public const string PARSE_NUMBER_CULTURE = "parse-number-culture";
+
         /// <summary>
         /// Rounds a numeric value to a specified number of fractional digits, using the away from zero rounding convention.
         /// </summary>

RainLisp/Interpreter.cs

@@ -338,6 +338,7 @@ void Install(string procedureName, Func<EvaluationResult[]?, EvaluationResult> i
             Install(DATETIME_TO_STRING, PrimitiveOperation.DateTimeToString);
             Install(NUMBER_TO_STRING, PrimitiveOperation.NumberToString);
             Install(PARSE_NUMBER, PrimitiveOperation.ParseNumber);
+            Install(PARSE_NUMBER_CULTURE, PrimitiveOperation.ParseNumberCulture);
             Install(ROUND, PrimitiveOperation.Round);
             Install(CEILING, PrimitiveOperation.Ceiling);
             Install(FLOOR, PrimitiveOperation.Floor);

RainLisp/RainLisp.csproj

@@ -6,7 +6,7 @@
     <Nullable>enable</Nullable>
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
     <Title>RainLisp a .NET LISP implementation</Title>
-    <Version>1.2.0</Version>
+    <Version>1.3.0</Version>
     <Description>RainLisp a .NET LISP implementation.</Description>
     <Copyright>2023</Copyright>
     <PackageProjectUrl>https://github.com/chr1st0scli/RainLisp</PackageProjectUrl>

RainLispTests/EvaluatorErrorTests.cs

@@ -98,7 +98,7 @@ public void Evaluate_CallExpectingTwoWithWrongNumberOfArguments_Throws(string ex
             Evaluate_CallsWithWrongNumberOfArguments_Throws(new[]
                 {
                     ">", ">=", "<", "<=", "=", "cons", "set-car!", "set-cdr!",
-                    "add-years", "add-months", "add-days", "add-hours", "add-minutes", "add-seconds", "add-milliseconds", "number-to-string",
+                    "add-years", "add-months", "add-days", "add-hours", "add-minutes", "add-seconds", "add-milliseconds", "number-to-string", "parse-number-culture",
                     "days-diff", "hours-diff", "minutes-diff", "seconds-diff", "milliseconds-diff", "parse-datetime", "datetime-to-string", "round"
                 }, expression, expected, false, actual);
         }
@@ -420,7 +420,7 @@ public void Evaluate_CallExpectingStringWithWrongTypeOfArgument_Throws(string ex
         [InlineData("({0} \"hello\" true)", typeof(BoolDatum))]
         public void Evaluate_CallExpecting2StringsWithWrongTypeOfArgument_Throws(string expression, Type actual)
         {
-            Evaluate_CallsWithWrongExpression_Throws(new[] { "parse-datetime" }, expression, actual, typeof(StringDatum));
+            Evaluate_CallsWithWrongExpression_Throws(new[] { "parse-datetime", "parse-number-culture" }, expression, actual, typeof(StringDatum));
         }
 
         [Theory]
@@ -587,6 +587,9 @@ public void Evaluate_ExpressionCallingNonProcedure_Throws(string expression)
         [InlineData("(replace-string \"hello\" \"\" \"world\")")]
         [InlineData("(parse-number \"\")")]
         [InlineData("(parse-number \"a\")")]
+        [InlineData("(parse-number-culture \"\" \"EN\")")]
+        [InlineData("(parse-number-culture \"a\" \"EN\")")]
+        [InlineData("(parse-number-culture \"1\" \"WQXY\")")]
         [InlineData("(round 2.5 -1)")]
         [InlineData("(round 2.5 29)")]
         public void Evaluate_ExpressionWithInvalidValue_Throws(string expression)

RainLispTests/EvaluatorTests.cs

@@ -100,6 +100,16 @@ public void Evaluate_StringLiteral_Correctly(string expression, string expectedR
         [InlineData("(parse-number \"2.5\")", 2.5d)]
         [InlineData("(parse-number \"21.53\")", 21.53d)]
         [InlineData("(parse-number \"21,53\")", 2153d)]
+        [InlineData("(parse-number-culture \"2\" \"\")", 2d)]
+        [InlineData("(parse-number-culture \"2\" \"en\")", 2d)]
+        [InlineData("(parse-number-culture \"21\" \"en\")", 21d)]
+        [InlineData("(parse-number-culture \"2.5\" \"en\")", 2.5d)]
+        [InlineData("(parse-number-culture \"2.5\" \"\")", 2.5d)]
+        [InlineData("(parse-number-culture \"2,5\" \"\")", 25d)]
+        [InlineData("(parse-number-culture \"21.53\" \"en\")", 21.53d)]
+        [InlineData("(parse-number-culture \"21.53\" \"el\")", 2153d)]
+        [InlineData("(parse-number-culture \"21,53\" \"en\")", 2153d)]
+        [InlineData("(parse-number-culture \"21,53\" \"el\")", 21.53d)]
         [InlineData("(round 2.5 0)", 3d)]
         [InlineData("(round 2.4 0)", 2d)]
         [InlineData("(round 21.423 2)", 21.42d)]

nuget.md

@@ -7,7 +7,7 @@ RainLisp is a programming language, belonging to the LISP family of languages, w
 
 It is not intended to replace your everyday programming language at work. Though, you can integrate it with your existing systems to allow for their configuration in terms of code.
 
-For example, one can build a system where parts of its computations or workflow logic is implemented in RainLisp. Its simplicity and capabilites make it ideal for using it like a DSL (Domain Specific Language) that integrates with your .NET system.
+For example, one can build a system where parts of its computations or workflow logic is implemented in RainLisp. Its simplicity and capabilities make it ideal for using it like a DSL (Domain Specific Language) that integrates with your .NET system.
 
 Additionally, you can easily extend it to implement your own LISP dialect or replace some of its components, like the tokenizer and parser, and reuse the evaluator to easily build an entirely different but compatible programming language.