Constants in Standard ML

Constants in Standard ML (SML) are handled differently than in some other languages. SML is a statically-typed, functional language, and creating constants involves defining values which are immutable by default.

Here is how you can declare constants and use them in SML:

Go supports constants of character, string, boolean, and numeric values.

val s : string = "constant"

Within a function, constants can be defined similarly and are immutable.

val _ =
    let
        val s = "constant"
        val n = 500000000
        val d = Real.fromInt (3 * 10.0E20) / Real.fromInt n
    in
        print (s ^ "\n");
        print (Real.toString d ^ "\n");
        print (Int.toString (Real.trunc d) ^ "\n");
        print (Real.toString (Math.sin (Real.fromInt n)) ^ "\n")
    end

Explanation#

1. String Constant:

   val s : string = "constant"

   This statement declares a string constant s with the value “constant”.

2. Main Function Equivalent:

   val _ = 
   let
       (* Declarations and operations inside a let block *)
   in
       (* Code executing those values *)
   end

   The let block is used to declare local constants and perform operations. The val _ = is a common idiom in SML to execute a block of code at startup.

3. Numeric Constants:

   val n = 500000000
   val d = Real.fromInt (3 * 10.0E20) / Real.fromInt n

   Here n is an integer constant, and d is a real number obtained by performing a division with high precision.

4. Printing Values:

   print (s ^ "\n");
   print (Real.toString d ^ "\n");
   print (Int.toString (Real.trunc d) ^ "\n");
   print (Real.toString (Math.sin (Real.fromInt n)) ^ "\n")

   These lines print the values of the constants s, d and some more complex expressions involving these constants. SML uses print for output, ^ for string concatenation, and functions from the Real and Math structures for numeric operations.

To run the above SML code, you can use an SML interpreter such as Moscow ML or SML/NJ. Save the code to a file, for example, constants.sml, and then run:

$ sml < constants.sml
constant
6.0e+11
600000000000
-0.28470407323754404

By this, we have utilized Standard ML to declare constants and perform arithmetic with arbitrary precision, similar to the provided example.