11 Apr Section

language features of Miranda

• pure functional - In a pure functional language, all computation is performed through evaluation of mathematical functions, and side effects are impossible. That is, once a variable is bound to a value, it cannot be changed. (Contrast this with languages like C, C++, and Java.) One of the benefits of this is referential transparency.
• referential transparency - In a language with referential transparency, if you know a particular expression X evaluates to a value or another expression, it is always safe to replace the X with this value or expression. In a pure functional language like Miranda, an expression like (x + 4) will always evaluate to the same value, because x's value can't be changed. In contrast, in C, C++, or Java, the value of (x + 4) can change as program execution proceeds if the value of x is changed.
• currying - partially applying a function (i.e., giving it fewer arguments than it requires), which evaluates to a new function that takes the remaining argument(s)
• first class functions - In a language with first class functions, functions are treated just like instances of any other data type (integers, Booleans, characters, whatever other types the language provides), meaning they can be bound to variables, passed to functions, returned from functions---all without any special syntax.
• higher order function - a function that takes a function as an argument and/or returns a function; roughly speaking, functions that compute on functions
• list comprehension - syntax for describing lists in terms of items chosen sequentially from another list and filtered according to conditional expressions
• pattern matching - defining a function with a formal parameter whose form is compared against the argument the caller passes in to determine which equation to use and/or how the argument should be decomposed for use in the function definition; e.g.,

  rec_length [] = 0
  rec_length (first:rest) = 1 + (rec_length rest)

  When the above function is called, Miranda will first check whether the argument matches [] (empty list) or (first:rest) (nonempty list) in form. If the argument matches (first:rest), the first item in the list is bound to first and the rest of the list to rest for use in the function definition.
• lazy evaluation - evaluation of expressions on a strictly as-needed basis; allows infinite data structures
• polymorphic type - a type defined in terms of another type (also, "parameterized type"); e.g., the binary tree type tree * from lecture, in contrast with the more limited (and not polymorphic) numtree type, which can only be used to store values of type num in a tree
• static typing - where the type of every expression is determined and fixed solely based on the code and can therefore be decided at compile time (contrast w/ dynamic typing, where an expression's type is not known until and can vary at run time)
• lexical scoping - where the scope of an identifier is restricted by code structure, e.g., with where in Miranda and curly braces in C, C++, Java
• type inference - as in Miranda, where the compiler can determine (in many cases) the type of an expression (including functions, since they are first class) without the programmer having to explicitly declare types (The compiler "infers" "types.")
• user-defined types - Types the language allows the user to define; e.g., C++ and Java allow the user to define new classes
• polymorphic function - in Miranda and other functional languages, a function with an argument whose type is not fixed to a single, specific type; similar but not identical to function overloading in C++ and Java, which is sometimes called ad-hoc polymorphism, where only the type signature and syntax of the function are reused, not the implementation as well (as is the case with polymorphic functions)