On a different note…<\/p>\n
In FORTRAN and Pascal and Ada, programming languages that I revelled in long ago, there is a distinction drawn between so-called procedures<\/em> on the one hand and functions<\/em> on the other. Both are software constructs for doing some work, but whereas a function calculates a tangible result and gives it back to the caller, a procedure does no such thing, performing instead some background operation on behalf of the caller (for instance printing some text to the screen or saving some data in a database).\u00a0<\/p>\n So in Ada you might write<\/p>\n and<\/p>\n In a sense, functions produce stuff that you can take with you whereas procedures just do stuff.<\/p>\n In contrast to this, the languages C, C++, C# and Java have no such distinction. They only have functions.<\/p>\n Well, that’s not quite right, because of course there’s still a need for algorithms that do stuff. And so in place of procedures, these languages define so-called void functions<\/em>. They produce nothing whence void<\/em>.<\/p>\n In a hypothetical language might this could take the following form.<\/p>\n To an engineer encountering this stuff for the first time, this notion of void functions<\/em> is entertaining. It’s novel to reflect on the notion that the void<\/em> has entered into an otherwise dry world of physics and equations of motion and all that.<\/p>\n But it’s not a confusing concept, so after a few minutes the novelty fades, and you proceed as you always have, writing some functions that\u00a0produce something and other procedures<\/span> functions that don’t.<\/p>\n Now, the languages mentioned above are examples of so-called statically typed languages<\/em>. That is to say, every algorithm expressed in these languages manipulates things<\/em> that have a so-called type<\/em>\u00a0(String, Integer, Character, …), and these types are explicitly specified by the programmer. So\u00a0you might wonder, What is this type called Well, I am not a programming expert, but my understanding is that in fact in these cases, Hm… It’s a hint that this function isn’t producing anything; that it’s only doing something. In other words, This state of affairs changes a bit in the Scala programming language, a language built on the conceptual foundations of C and Java but one that goes in some fundamentally different directions.<\/p>\n Scala generalizes the notion of Or using the Ada-like pseudocode we’ve used above,<\/p>\n The only real difference here is the presence of Once upon a time I was working with a bunch of rocket scientists. We were building a new space transportation system that was going to take us to orbit, take us to the moon and eventually take us to Mars. One of the projects I was working on involved designing a schema for representing complex datasets in a way that future engineers and software developers could understand long after the original authors were gone. (This system was being designed for the long-haul, an irony given that the project was eventually cancelled.)<\/p>\n I worked with a couple computer science-y, math-y guys from California. They were bright, and they were determined to apply their dreams of ontologies to the problem I was working on. One day we were discussing how to specify … nothing — how to formally indicate that there was nothing there there<\/em>.<\/p>\n “Can we call this Unit<\/em>?” Oliver asked.<\/p>\n I was puzzled. Why would we call nothing one?<\/p>\n See the connection, here?<\/p>\n I’m not a computer scientist. Indeed, in an interview question long ago, I was asked some computer science-y, algorithm-theoretical question to which said, “I confess I’m not strong in …” to which the questioner responded, “Aren’t all computer scientists strong in …?” to which I reminded him that my background was in engineering.<\/p>\nfunction Translate( english_word : String ) return String is\nbegin\n\t...translation algorithm here...\n\treturn swahili_word;\nend\n<\/pre>\n
procedure Display( sentence : String ) is\nbegin\n\t...output algorithm here...\nend\n<\/pre>\n
2. Unifying Them Both<\/h3>\n
function Display( sentence : String ) return void is\nbegin\n\t...output algorithm here...\nend\n<\/pre>\n
3.
void<\/code> Isn’t a Type<\/h3>\nvoid<\/code>?<\/em><\/p>\nvoid<\/code> isn’t really a type per se. It’s just a hint to the computer that this particular function actually doesn’t return anything.<\/p>\nvoid<\/code> is just an annotation that says, Hah! Fooled you. This isn’t really a function at all; it’s a procedure.<\/em><\/p>\n4. Introducing
Unit<\/code><\/h3>\nvoid<\/code> to a full-fledged type called Unit<\/code>. So in Scala you might write something like this.<\/p>\ndef Display( sentence : String ) : Unit =\u00a0\n{\n\t...output algorithm here...\n}\n<\/pre>\nfunction Display( sentence : String ) return Unit is\nbegin\n\t...output algorithm here...\nend\n<\/pre>\n
Unit<\/code> instead of void<\/code>. But in Scala, this is no minor detail. Whereas the void<\/code> of C is a kind of hint, Scala’s Unit<\/code> is a bonafide type.<\/p>\n5. A Tangent on the Notion of
Unit<\/code><\/h3>\nUnit<\/code> made me do a double-take when I first saw it. After all, using Unit<\/code> to represent “nothing” sounds perilously close to the heresy of claiming that 1=0<\/code>. It turns out that I’ve run into this heresy before.\u00a0<\/p>\n6. Another Tangent<\/h3>\n