Question

F# allows to use checked arithmetics by opening Checked module, which redefines standard operators to be checked operators, for example:

open Checked
let x = 1 + System.Int32.MaxValue // overflow

will result arithmetic overflow exception.

But what if I want to use checked arithmetics in some small scope, like C# allows with keyword checked:

int x = 1 + int.MaxValue;             // ok
int y = checked { 1 + int.MaxValue }; // overflow

How can I control the scope of operators redefinition by opening Checked module or make it smaller as possible?

Answer 1

You can always define a separate operator, or use shadowing, or use parens to create an inner scope for temporary shadowing:

let f() =
    // define a separate operator
    let (+.) x y = Checked.(+) x y
    try 
        let x = 1 +. System.Int32.MaxValue
        printfn "ran ok"
    with e ->
        printfn "exception"
    try 
        let x = 1 + System.Int32.MaxValue
        printfn "ran ok"
    with e ->
        printfn "exception"
    // shadow (+)
    let (+) x y = Checked.(+) x y
    try 
        let x = 1 + System.Int32.MaxValue
        printfn "ran ok"
    with e ->
        printfn "exception"
    // shadow it back again
    let (+) x y = Operators.(+) x y
    try 
        let x = 1 + System.Int32.MaxValue
        printfn "ran ok"
    with e ->
        printfn "exception"
    // use parens to create a scope
    (
        // shadow inside
        let (+) x y = Checked.(+) x y
        try 
            let x = 1 + System.Int32.MaxValue
            printfn "ran ok"
        with e ->
            printfn "exception"
    )            
    // shadowing scope expires
    try 
        let x = 1 + System.Int32.MaxValue
        printfn "ran ok"
    with e ->
        printfn "exception"


f()    
// output:
// exception
// ran ok
// exception
// ran ok
// exception
// ran ok

Finally, see also the --checked+ compiler option:

http://msdn.microsoft.com/en-us/library/dd233171(VS.100).aspx