side-effects

Is there any way to prevent side effects in python? For example, the following function has a side effect, is there any keyword or any other way to have the python complain about it? def func_with_side_affect(a): a.append('foo') Python is really not set up to enforce prevention of side-effects. As some others have mentioned, you can try to deepcopy the data or use immutable types, but these still have corner cases that are tricky to catch, and it's just a ton more effort than it's worth. Using a functional style in Python normally involves the programmer simply designing their functions to be

Oracle's documentation on atomic access (at http://docs.oracle.com/javase/tutorial/essential/concurrency/atomic.html ) says this: "a volatile variable establishes a happens-before relationship... . This means that ... when a thread reads a volatile variable, it sees not just the latest change to the volatile, but also the side effects of the code that led up the change." I'm having trouble wrapping my head around that. I understand how volatile variables work (in >= Java 5), but I'm wondering how the java decides what side-affect "led up" to the change of a volatile variable. So I guess my

A programming pattern like this comes up every so often: int staleCount = 0; fileUpdatesGridView.DataSource = MultiMerger.TargetIds .Select(id => { FileDatabaseMerger merger = MultiMerger.GetMerger(id); if (merger.TargetIsStale) staleCount++; return new { Id = id, IsStale = merger.TargetIsStale, // ... }; }) .ToList(); fileUpdatesGridView.DataBind(); fileUpdatesMergeButton.Enabled = staleCount > 0; I'm not sure there is a more succinct way to code this? Even if so, is it bad practice to do this? No, it is not strictly "bad practice" (like constructing SQL queries with string concatenation of

I just got my copy of Expert F# 2.0 and came across this statement, which somewhat surprised me: For example, when necessary, you can use side effects on private data structures allocated at the start of an algorithm and then discard these data structures before returning a result; the overall result is then effectively a side-effect-free function. One example of separation from the F# library is the library's implementation of List.map, which uses mutation internally; the writes occur on an internal, separated data structure that no other code can access. Now, obviously the advantage to this

In a Functional Programming book the author mentions the following are the side effects. Modifying a variable Modifying a data structure in place Setting a field on an object Throwing an exception or halting with an error Printing to the console or reading user input Reading from or writing to a file Drawing on the screen I am just wondering how it is possible to write pure functional program without reading or writing to a file if they are side effects. If yes what would be the common approach in the functional world to achieve this ? Thanks, Mohamed Properly answering this question requires

I have read in C++ : The Complete Reference book the following Even though objects are passed to functions by means of the normal call-by-value parameter passing mechanism, which, in theory, protects and insulates the calling argument, it is still possible for a side effect to occur that may affect, or even damage, the object used as an argument. For example, if an object used as an argument allocates memory and frees that memory when it is destroyed, then its local copy inside the function will free the same memory when its destructor is called. This will leave the original object damaged and