referential-transparency

I've played around with a few functional programming languages and really enjoy the s-expr syntax used by Lisps (Scheme in particular). I also see the advantages of working in a purely functional language. Therefore: Are there any purely functional Schemes (or Lisps in general)? Probably not, at least not as anything other than toys/proofs of concept. Note that even Haskell isn't 100% purely functional--it has secret escape hatches, and anything in IO is only "pure" in some torturous, hand-waving sense of the word . So, that said, do you really need a purely functional language? You can write

Since side-effects break referential transparency, don't they go against the point of functional languages? There are two techniques that are used by purely functional programming languages to model side effects: 1) A world type that represents external state, where each value of that type is guaranteed by the type system to be used only once. In a language that uses this approach the function print and read might have the types (string, world) -> world and world -> (string, world) respectively. They might be used like this: let main w = let w1 = print ("What's your name?", w) in let (str, w2)

The terms do appear to be defined differently, but I've always thought of one implying the other; I can't think of any case when an expression is referentially transparent but not pure, or vice-versa. Wikipedia maintains separate articles for these concepts and says: From Referential transparency : If all functions involved in the expression are pure functions, then the expression is referentially transparent. Also, some impure functions can be included in the expression if their values are discarded and their side effects are insignificant. From Pure expressions : Pure functions are required

I've frequently heard claims that Haskell doesn't have variables; in particular, this answer claims that it doesn't, and it was upvoted at least nine times and accepted. So does it have variables or not, and why? This question also appears to apply ML, F#, OCaml, Erlang, Oz, Lava, and all SSA intermediate languages. Don Stewart Haskell has immutable variables (variables in the math sense) by default: foo x y = x + y * 2 By default variables are not mutable cells . Haskell also has mutable cells though, but you enable them explicitly: > import Data.IORef (newIORef, readIORef, writeIORef) > v <-

I need small lists of gaussian random numbers for a simulation and so I tried the following: import System.Random seed = 10101 gen = mkStdGen seed boxMuller mu sigma (r1,r2) = mu + sigma * sqrt (-2 * log r1) * cos (2 * pi * r2) This is just the Box-Muller algorithm - given r1, r2 uniform random numbers in the [0,1] interval it returns a gaussian random number. normals 0 g = [] normals n g = take n $ map (boxMuller 0 1) $ pairs $ randoms g where pairs (x:y:zs) = (x,y):(pairs zs) So I used this normals function everytime I needed my list of random numbers. The problem with that must be apparent:

After touching on Monads in respect to functional programming, does the feature actually make a language pure, or is it just another "get out of jail free card" for reasoning of computer systems in the real world, outside of blackboard maths? EDIT: This is not flame bait as someone has said in this post, but a genuine question that I am hoping that someone can shoot me down with and say, proof, it is pure. Also I am looking at the question with respect to other not so pure Functional Languages and some OO languages that use good design and comparing the purity. So far in my very limited world

What does the term referential transparency mean? I've heard it described as "it means you can replace equals with equals" but this seems like an inadequate explanation. Uday Reddy The term "referential transparency" comes from analytical philosophy , the branch of philosophy that analyzes natural language constructs, statements and arguments based on the methods of logic and mathematics. In other words, it is the closest subject outside computer science to what we call programming language semantics . The philosopher Willard Quine was responsible for initiating the concept of referential