OCaml: Does storing some values to be used later introduce "side effects"?

For a homework assignment, we've been instructed to complete a task without introducing any "side-effects". I've looked up "side-effects" on Wikipedia, and though I get that in theory it means "modifies a state or has an observable interaction with calling functions", I'm having trouble figuring out specifics.

For example, would creating a value that holds a non-compile time result be introducing side effects?

Say I had (might not be syntactically perfect):

val myList = (someFunction x y);;
if List.exists ((=) 7) myList then true else false;;

Would this introduce side-effects? I 开发者_如何学Goguess maybe I'm confused on what "modifies a state" means in the definition of side-effects.

---

No; a side-effect refers to e.g. mutating a ref cell with the assignment operator :=, or other things where the value referred to by a name changes over time. In this case, myList is an immutable value that never changes during the program, thus it is effect-free.

See also

http://en.wikipedia.org/wiki/Referential_transparency_(computer_science)

---

A good way to think about it is "have I changed anything which any later code (including running this same function again later) could ever possibly see other than the value I'm returning?" If so, that's a side effect. If not, then you can know that there isn't one.

So, something like:

let inc_nosf v = v+1

has no side effects because it just returns a new value which is one more than an integer v. So if you run the following code in the ocaml toplevel, you get the corresponding results:

# let x = 5;;
val x : int = 5
# inc_nosf x;;
- : int = 6
# x;;
- : int = 5

As you can see, the value of x didn't change. So, since we didn't save the return value, then nothing really got incremented. Our function itself only modifies the return value, not x itself. So to save it into x, we'd have to do:

# let x = inc_nosf x;;
val x : int = 6
# x;;
- : int = 6

Since the inc_nosf function has no side effects (that is, it only communicates with the outside world using its return value, not by making any other changes).

But something like:

let inc_sf r = r := !r+1

has side effects because it changes the value stored in the reference represented by r. So if you run similar code in the top level, you get this, instead:

# let y = ref 5;;
val y : int ref = {contents = 5}
# inc_sf y;;
- : unit = ()
# y;;
- : int ref = {contents = 6}

So, in this case, even though we still don't save the return value, it got incremented anyway. That means there must have been changes to something other than the return value. In this case, that change was the assignment using := which changed the stored value of the ref.

As a good rule of thumb, in Ocaml, if you avoid using refs, records, classes, strings, arrays, and hash tables, then you will avoid any risk of side effects. Although you can safely use string literals as long as you avoid modifying the string in place using functions like String.set or String.fill. Basically, any function which can modify a data type in place will cause a side effect.