 Miranda (programming language)

Miranda Paradigm(s) lazy, functional, declarative Appeared in 1985 Designed by David Turner Developer Research Software Ltd Typing discipline strong, static Major implementations Miranda Influenced by KRC, ML, SASL, Hope Influenced Haskell Website miranda.org.uk Miranda is a nonstrict purely functional programming language designed by David Turner as a successor to his earlier programming languages SASL and KRC, using some concepts from ML and Hope. It was produced by Research Software Ltd. of England (which holds a trademark on the name Miranda) and was the first purely functional language to be commercially supported.
Miranda was first released in 1985, as a fast interpreter in C for Unixflavour operating systems, with subsequent releases in 1987 and 1989. The later Haskell programming language is similar in many ways to Miranda.
Overview
Miranda is a lazy, purely functional programming language. That is, it lacks side effects and imperative programming features. A Miranda program (called a script) is a set of equations that define various mathematical functions and algebraic data types. The word set is important here: the order of the equations is, in general, irrelevant, and there is no need to define an entity prior to its use.
Since the parsing algorithm makes intelligent use of layout (indentation), there is rarely a need for bracketing statements and no statement terminators are required. This feature, inspired by ISWIM is also used in occam and Haskell and was later popularized by Python.
Commentary is introduced into regular scripts by the characters

and continue to the end of the same line. An alternative commenting convention affects an entire source code file, known as a "literate script", in which every line is considered a comment unless it starts with a>
sign.Miranda's basic data types are
char
,num
andbool
. A character string is simply a list ofchar
, whilenum
is silently converted between two underlying forms: arbitraryprecision integers (a.k.a. bignums) by default, and regular floating point values as required.Tuples are sequences of elements of potentially mixed types, analogous to records in Pascallike languages, and are written delimited with parentheses:
this_employee = ("Folland, Mary", 10560, False, 35)
The list instead is the most commonly used data structure in Miranda. It is written delimited by square brackets and with commaseparated elements, all of which must be of the same type:
week_days = ["Mon","Tue","Wed","Thur","Fri"]
List concatenation is
++
, subtraction is
, construction is:
, sizing is#
and indexing is!
, so:days = week_days ++ ["Sat","Sun"] days = "Nil":days days!0 → "Nil" days = days  ["Nil"] #days → 7
There are several listbuilding shortcuts:
..
is used for lists whose elements form an arithmetic series, with the possibility for specifying an increment other than 1:fac n = product [1..n] odd_sum = sum [1,3..100]
More general and powerful listbuilding facilities are provided by "list comprehensions" (previously known as "ZF expressions"), which come in two main forms: an expression applied to a series of terms, e.g.:
squares = [ n * n  n < [1..] ]
(which is read: list of n squared where n is taken from the list of all positive integers) and a series where each term is a function of the previous one, e.g.:
powers_of_2 = [ n  n < 1, 2*n .. ]
As these two examples imply, Miranda allows for lists with an infinite number of elements, of which the simplest is the list of all positive integers:
[1..]
The notation for function application is simply juxtaposition, as in
sin x
.In Miranda, as in most other purely functional languages, functions are firstclass citizens, which is to say that they can be passed as parameters to other functions, returned as results, or included as elements of data structures. What is more, a function requiring two or more parameters may be "partially parameterised", or curried, by supplying less than the full number of parameters. This gives another function which, given the remaining parameters, will return a result. For example:
add a b = a + b increment = add 1
is a roundabout way of creating a function "increment" which adds one to its argument. In reality,
add 4 7
takes the twoparameter functionadd
, applies it to4
obtaining a singleparameter function that adds four to its argument, then applies that to7
.Any function taking two parameters can be turned into an infix operator (for example, given the definition of the
add
function above, the term$add
is in every way equivalent to the+
operator) and every infix operator taking two parameters can be turned into a corresponding function. Thus:increment = (+) 1
is the briefest way to create a function that adds one to its argument. Similarly, in
half = (/ 2) reciprocal = (1 /)
two singleparameter functions are generated. The interpreter understands in each case which of the divide operator's two parameters is being supplied, giving functions which respectively divide a number by two and return its reciprocal.
Although Miranda is a strongly typed programming language, it does not insist on explicit type declarations. If a function's type is not explicitly declared, the interpreter infers it from the type of its parameters and how they are used within the function. In addition to the basic types (
char
,num
,bool
), it includes an "anything" type where the type of a parameter does not matter, as in the listreversing function:rev [] = [] rev (a:x) = rev x ++ [a]
which can be applied to a list of any data type, for which the explicit function type declaration would be:
rev :: [*] > [*]
Finally, it has mechanisms for creating and managing program modules whose internal functions are invisible to programs calling those modules.
Sample code
The following Miranda script determines the set of all subsets of a set of numbers
subsets [] = [[]] subsets (x:xs) = [[x] ++ y  y < ys] ++ ys where ys = subsets xs
and this is a literate script for a function
primes
which gives the list of all prime numbers>  The infinite list of all prime numbers, by the sieve of Eratosthenes. The list of potential prime numbers starts as all integers from 2 onwards; as each prime is returned, all the following numbers that can exactly be divided by it are filtered out of the list of candidates. > primes = sieve [2..] > sieve (p:x) = p : sieve [n  n < x; n mod p ~= 0]
External links
Categories: Declarative programming languages
 Functional languages
Wikimedia Foundation. 2010.
Look at other dictionaries:
Haskell (programming language) — Haskell Paradigm(s) functional, lazy/non strict, modular Appeared in 1990 Designed by Simon Peyton Jones, Lennart Aug … Wikipedia
Newspeak (programming language) — Newspeak Paradigm(s) object oriented, functional Appeared in 2006 Designed by Gilad Bracha Developer Gilad Bracha, Peter von der Ahé, Vassili Bykov, Yaron Kashai, William Maddox, Eliot Miranda Stable releas … Wikipedia
SASL (programming language) — Infobox programming language name = SASL paradigm = functional year = 1972 designer = David Turner developer = latest release version = latest release date = latest test version = latest test date = typing = implementations = dialects =… … Wikipedia
Orwell (programming language) — Orwell Paradigm(s) Lazy functional Appeared in 1984 Designed by Philip Wadler Influenced by Miranda Influenced Haskell Orwell … Wikipedia
ML (programming language) — ML Paradigm(s) multi paradigm: imperative, functional Appeared in 1973 Designed by Robin Milner others at the University of Edinburgh Typing discipline static, strong, inferred … Wikipedia
Strict programming language — A strict programming language is one in which only strict functions (functions whose parameters must be evaluated completely before they may be called) may be defined by the user. A non strict programming language allows the user to define non… … Wikipedia
SAC programming language — Infobox programming language name = SAC paradigm = array, functional year = 1994 designer = Sven Bodo Scholz, Clemens Grelck, et al developer = latest release version = latest release date = typing = static, strong implementations = dialects =… … Wikipedia
Hope (programming language) — Hope is a small functional programming language developed in the early 1980s prior to Miranda and Haskell. It is notable for being the first language with call by pattern evaluation and algebraic data types. Hope is an important language in the… … Wikipedia
Miranda — may refer to : Contents 1 Places 2 People 3 Arts and entertainment 4 Other uses 5 See also … Wikipedia
List of functional programming topics — This is a list of functional programming topics. Contents 1 Foundational concepts 2 Lambda calculus 3 Combinatory logic 4 Intuitionistic logic … Wikipedia