1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

// Calculates as if there is no tomorrow

#light

namespace FS

open System
open System.Text.RegularExpressions

module SimpleCalculator =
    // Regular expression pattern discriminator
    let (|Match|_|) pattern s =
        Regex.Match(s, pattern).Success
        |> fun matches ->
            match matches with
            | true -> Some()
            | false -> None

    // Token type pattern discriminator
    let internal (|Number|Operator|Space|Invalid|Empty|) (s : string) =
        match s with
        | Match "[0-9.,]+" -> Number
        | Match "[\\+\\-\\*/]" -> Operator
        | " " -> Space
        | "" -> Empty
        | _ -> Invalid

    // Determines if the specified character is a token separator
    let IsSeparator(ch : char) =
        match string ch with
        | Number -> false
        | _ -> true

    // Returns a tuple of (next token : string * remainder : string)
    let NextToken(s : string) =
        s.ToCharArray()
        |> Array.tryFindIndex (fun c -> IsSeparator(c))
        |> fun x ->
            match x with
            | Some(0) -> (s.Substring(0, 1), s.Substring(1)) // <--- the special case of finding a separator @ 0
            | Some(x) -> (s.Substring(0, x), s.Substring(x))
            | _ -> (s), ""
    
    // Produces a sequence of tokens from a string
    let rec Tokenize (s : string) =
        seq { 
            let token, remainder = NextToken(s)
            match token with
            | Space -> ()
            | _ -> yield token
            match remainder with
            | Empty -> ()
            | _ -> yield! Tokenize(remainder)
        }

    // Evaluates a string mathematically
    let Eval (s : string) : float =
        Array.ofSeq (Tokenize (s))
        |> fun ar -> 
            let v1 = Double.Parse ar.[0]
            let o = ar.[1]
            let v2 = Double.Parse ar.[2]            
            match o with
            | "+" -> v1 + v2
            | "-" -> v1 - v2
            | "*" -> v1 * v2
            | "/" -> v1 / v2
            | Invalid | _ -> failwith ("invalid operator: " + o)

    // Main function
    System.Console.ReadLine()
    |> Eval
    |> System.Console.WriteLine