Programmings languages that are immutable by default?

Are there programming languag开发者_如何学Ces whose "variables" are immutable (const, final, etc) by default?

And, to make it variable, you need to declare an additional immutable qualifier ?

The philosophy of the Functional Programming paradigm is strongly geared towards all "variables" being immutable, and "mutable" ones being only allowed in extreme cases (ie, for I/O). Therefore, most functional programming languages like the various Lisp dialects and Haskell will (more often than not) reinforce immutable variables. Of course, some languages offer more flexibility than others, but the central paradigm/philosophy remains, that discourages it.

Edit: In response to your edit:

If you are looking for a C-with-friendlier-constants, then adopting an entirely new programming paradigm isn't your solution. In Functional programming, everything is immutable (in most cases), and you're generally looking at a whole new fundamental philosophy and approach to programming.

This isn't really a solution if all you want is to make it easier to declare constants.

Edit2: In response to people upvoting me:

While I did correctly (I hope) answer the asker's question, I'm not sure it was an answer that turned out to be useful, given his new edit/comment. However, I can hope to possibly open his eyes to a whole new beautiful world of programming =)

Edit3: Here is Wikipedia's List of functional programming languages:

• APL
• Charity (purely functional)
• Clean (purely functional)
• Curl
• Curry
• Erlang
• F#
• Haskell (purely functional)
  • CAL
• Hop
• J
• Joy
• Kite
• Lisp
  • Clojure
  • Common Lisp
  • Dylan
  • Little b
  • Logo
  • Scheme
  • Tea
• Lush
• Mathematica
• Miranda
• ML
  • Standard ML
  • Alice
  • Ocaml
  • Mythryl
• Nemerle
• Opal
• OPS5
• Poplog
• R
• Q
• REFAL
• Russell
• Scala
• Spreadsheets

Most of these languages have some minor elements/influences of non-functional heresy; the ones labeled "purely functional" do not.

(To my knowledge, Functional Programming languages are the only ones that encourage immutable variables by philosophy. There may be languages that have variables immutable, by default, that are not Functional by paradigm. The concept sounds quite odd to me, but I can't guarantee a blanket "never ever" statement, given the vast, vast, vast number of programming languages out there. I'll just say that it is, to my knowledge, extremely unlikely)

A commenter has suggested that ADA is an Imperative/Object-Oriented programming language with immutable variables by default.

Yes.

Haskell and Erlang are two examples.

Clojure is a Lisp dialect targeting the Java Virtual Machine working exclusively with immutable data.

http://www.clojure.org

The closest analog I can think of is Objective Caml. Variables bound by let are always immutable, but the fields of structures (called records in Caml) are immutable only by default, and it is possible to tag an individual field as mutable.

Among functional languages, Objective Caml has proven remarkably attractive to C programmers. OCaml has quite a few imperative constructs in both the language and libraries, so the migration path is not so strange. And if you really want objects and a class system, they are there too.

Microsoft's .NET language F# is a descendant of Objective Caml, but there have been quite a few changes to make sure it is a .NET language, and I am not informed about mutability. But if you are wanting to try out a functional language as a relatively small change from your current programming style, you might wish to investigate Objective Caml or F#.

Rust might be something you'd want to take a look at. Its an imperative-style language that adhere's to functional programming philosophy surprisingly often.

All variables in XSLT may only be immutable.