Show

The use of show for converting objects to their print representations

The need often arises to convert an arbitrary Miranda value to its printable representation as a string. For numbers the function shownum (of type num->[char]) can be used for this purpose. To be able to do this conversion for any type of object would seemingly require an infinite number of functions, one for each type. As a solution to this problem Miranda provides a special keyword, show.

For any object x

        show x

is a string containing the printable representation of x. For example, if x is a number the above expression is equivalent to shownum x. In the general case, however, x could be a structured object of arbitrary complexity. Note that show is a reserved word, not an identifier.

In fact show behaves under most circumstances as though it was the name of a function, of type *->[char]. For example it can be passed as a parameter, so that say,

        map show [a,b,c,d,e]

is a legal expression of type [[char]].

There are three important restrictions on the universality of show.

(i) You cannot show functions in any useful sense. (That would be a violation of referential transparency.) The result of applying show to any kind of function is just the string \"\<function>\".

(ii) You cannot show an abstract object unless an appropriate show-function was included when the type was defined (see manual section on Abstract types). The result of applying show to such an object is by default just the string \"\<abstract ob>\".

(iii) When it occurs in a script the context in which show is used must be such as to determine its type [monomorphically]{.underline}. An example:

        my_show x = "hello\n"++show x++"goodbye\n"

In the absence of any other type information, the compiler will infer that my_show has type *->[char], and that x is of type \*. The use of show is therefore polymorphic, and will be rejected as illegal.

If however we intend that my_show will be used only on objects of type tree, say, and we add to the script the declaration my_show::tree-\>\[char\], then the above use of show becomes monomorphic, and will be accepted.

The essence of restriction (iii) is that show is not a true polymorphic function of type *->[char], but rather a family of monomorphic functions with the types T->[char] for each possible monotype T. The context must be sufficient for the compiler to determine which member of the family is required.

(For technical reasons this restriction applies only in scripts. In command-level expressions show behaves as if it were a genuine polymorphic function.)