Ask HN: What would Your_Favorite_Compiler do?

    val x = unsafePerformIO $ readIORef x

    inc x = unsafePerformIO $ modifyIORef x (1+) >> readIORef x

    main = do
      x <- newIORef (10::Int)
      print $ val x + inc x

    main = do
      x <- newIORef (10::Int)
      print $ reverse $ val x : inc x : []

    >>> x = 10
    >>> x + ++x
    20

    expression( ... ++x ... )

    x = x+1;
    expression( ... x ... )

    1. put x=x+1 before the expression
    2. replace ++x with x

    # let x = 10;;
    val x : int = 10
    # let y = x + ++x;;
    Error: Syntax error

    # let x = ref 10;;
    val x : int ref = {contents = 10}
    # let y = !x + incr x;;
    Error: This expression has type unit but an expression was expected of type int

    y = operator+(x, operator++(x));

  (let* ((x 10)
         (y x))
    (+ x (incf x)))

  vs

  (let* ((x 10)
         (y x))
    (prog1
      (+ x x)
      (incf x)))   

  [INCF does it with side-effects, use 1+ or directly evaluate  (+ 1 x) for the clean version]