Difference between revisions of "IO Semantics"
m |
m |
||
(4 intermediate revisions by the same user not shown) | |||
Line 8: | Line 8: | ||
<b>The Limit Computable or Approximation Model</b> |
<b>The Limit Computable or Approximation Model</b> |
||
− | There exists a sequence of Turing programs |
+ | There exists a sequence of Turing programs <math>\{P_t:t \in T\}</math> so that |
− | < |
+ | <math>P_t</math> computes function <math>g_t</math> at time <math>{t \in T}</math>. There is not |
necessarily any connection between different programs and computing may have to |
necessarily any connection between different programs and computing may have to |
||
− | start all over again with a new program as the time changes from < |
+ | start all over again with a new program as the time changes from <math>t</math> to <math>t+1</math>. |
− | Suppose a meteorologist receives data every second < |
+ | Suppose a meteorologist receives data every second <math>t \in T</math> from weather |
stations scattered across the country. The configuration at the meteorologist's |
stations scattered across the country. The configuration at the meteorologist's |
||
desk may be described using the Shoenfield Limit Lemma by a computable function |
desk may be described using the Shoenfield Limit Lemma by a computable function |
||
− | where < |
+ | where <math>g_t</math> is the computable characteristic function of |
− | < |
+ | <math>B_t</math>, the configuration of the meteorological computation at the end |
− | of time < |
+ | of time <math>t</math>. The computable function <math>g_t</math> gives an algorithm to |
− | compute the condition < |
+ | compute the condition <math>B_t</math> at time <math>t</math> but it gives no relationship |
− | between < |
+ | between <math>B_t</math> and <math>B_{t+1}</math>. It will not be possible for the |
meteorologist to run, let alone write a new program every second. How will the |
meteorologist to run, let alone write a new program every second. How will the |
||
− | meteorologist write a program to uniformly compute the index < |
+ | meteorologist write a program to uniformly compute the index <math>g_t</math> |
− | for < |
+ | for <math>{t \in T}</math>? |
<b>The Online Model With an Oracle Machine</b> |
<b>The Online Model With an Oracle Machine</b> |
||
− | By the Shoenfield Limit Lemma there is a computably enumerable set < |
+ | By the Shoenfield Limit Lemma there is a computably enumerable set <math>{A}</math> (or even |
− | a |
+ | a <math>\Delta_2^0</math> set) and oracle machine <math>\Phi_e</math> such that |
− | < |
+ | <math>B = \Phi_e^A</math>. Now the meteorologist can program the |
− | algorithm |
+ | algorithm <math>\Phi_e</math> into a computer once and for all at the start of the |
− | day. Every second < |
+ | day. Every second <math>{t \in T}</math> the meteorologist receives from the weather stations |
− | the latest readings < |
+ | the latest readings <math>A_t</math> which enter directly into that computer by |
an network connection. The meteorologist does not (and cannot) change the |
an network connection. The meteorologist does not (and cannot) change the |
||
− | program |
+ | program <math>\Phi_e</math> every second. The algorithm simply receives the |
− | “oracle” information < |
+ | “oracle” information <math>A_t</math> from the weather-station network as it is continually |
− | updated, and computes the approximation < |
+ | updated, and computes the approximation <math>B_t(x) = \Phi_e^{A_t}(x)</math>. |
− | + | The meteorologist's program |
|
then produces the next scheduled weather forecast for the day from the |
then produces the next scheduled weather forecast for the day from the |
||
algorithm's result. It is difficult to see how this meteorologist could have |
algorithm's result. It is difficult to see how this meteorologist could have |
||
Line 46: | Line 46: | ||
== More is needed == |
== More is needed == |
||
− | But the |
+ | But the forecasting program would be one of many running on the meteorologist's |
− | + | computer: there could be a program that uploads the resulting weather forecasts, |
|
− | + | for example, to media outlets to be broadcast to listeners or viewers. Another |
|
+ | program could be working with devices such as: |
||
− | Another machine model is needed, not just for interactions with other |
||
− | computers but also: |
||
* a screen, to view a document, |
* a screen, to view a document, |
||
* a printer, to have a hard copy of a document, |
* a printer, to have a hard copy of a document, |
||
− | * a speaker, to produce some sound |
+ | * a speaker, to produce some sound. |
+ | |||
− | * a keyboard, mouse, microphone or controller, to obtain some input, |
||
+ | Furthermore, the meteorologist may for some reason decide to intervene while |
||
− | * [https://www.cs.virginia.edu/~robins/Turing_Paper_1936.pdf an operator], if an "arbitrary choice” is needed, |
||
+ | those programs are running (perhaps restarting them to provide more accurate |
||
− | * [https://pure.mpg.de/rest/items/item_2403325_2/component/file_2403324/content an oracle], which simply “cannot be a machine”. |
||
+ | forecasts after the addition of new weather stations to the network). Given |
||
+ | these extra requirements, will separate models be needed for each program? |
||
+ | Or is there one model versatile enough for all of the meteorologist's |
||
+ | programs? |
||
<blockquote> |
<blockquote> |
||
Line 66: | Line 69: | ||
pressed on the computer’s keyboard by reading another. |
pressed on the computer’s keyboard by reading another. |
||
− | <small>[https://web.archive.org/web/20160527210838/https://www.edsko.net/pubs/thesis.pdf Making uniqueness types less unique] (page 23 of 264).</small> |
+ | :<small>[https://web.archive.org/web/20160527210838/https://www.edsko.net/pubs/thesis.pdf Making uniqueness types less unique] (page 23 of 264).</small> |
</blockquote> |
</blockquote> |
||
− | So a choice machine could merely be an automatic machine given an extra |
+ | So a choice machine could merely be an automatic machine given an extra |
− | to make requests to external entities while it is running: |
+ | ability to make requests to external entities while it is running: |
− | * requests for <i>output</i> to a screen, printer or speaker |
+ | * requests for <i>output</i> to a screen, printer or speaker; |
− | * or for <i>input</i> from a keyboard, mouse, microphone, controller, an operator or |
+ | * or for <i>input</i> from a keyboard, mouse, microphone, controller, an [https://www.cs.virginia.edu/~robins/Turing_Paper_1936.pdf operator] or [https://pure.mpg.de/rest/items/item_2403325_2/component/file_2403324/content oracle]. |
with an oracle machine then being a specialised choice machine. Therefore if |
with an oracle machine then being a specialised choice machine. Therefore if |
||
an automatic machine computes the result of an ordinary expression (like |
an automatic machine computes the result of an ordinary expression (like |
||
− | <code>56 + 24</code>), a choice machine computes the result of an I/O action |
+ | <code>56 + 24</code>), a choice machine computes the result of an I/O action |
− | <code>getChar</code>) when the action is provided with an external-entity |
+ | (like <code>getChar</code>) when the action is provided with an external-entity |
− | this concept be adapted for use in a <i>functional</i> |
+ | request. So how can this concept be adapted for use in a <i>functional</i> |
+ | language like Haskell? |
||
== Two different approaches == |
== Two different approaches == |
||
Line 228: | Line 232: | ||
</haskell> |
</haskell> |
||
− | <code>Control.Parallel.pseq</code> is needed because <code>Prelude.seq</code> [ |
+ | <code>Control.Parallel.pseq</code> is needed because <code>Prelude.seq</code> is [[Seq|non]]-sequential, prior evidence to the contrary notwithstanding. |
− | the fact that a sequencing definition was a known necessity [https://web.archive.org/web/20040228202402/http://www.dcs.gla.ac.uk/fp/workshops/fpw96/Trinder.pdf since 1996] |
||
− | notwithstanding. |
||
== <span id="readmore"></span> Further reading == |
== <span id="readmore"></span> Further reading == |
Latest revision as of 14:00, 16 October 2024
An adapted example
Based on page 42 of 76 in Turing-Post Relativized Computability and Interactive Computing:
The Limit Computable or Approximation Model
There exists a sequence of Turing programs so that computes function at time . There is not necessarily any connection between different programs and computing may have to start all over again with a new program as the time changes from to .
Suppose a meteorologist receives data every second from weather stations scattered across the country. The configuration at the meteorologist's desk may be described using the Shoenfield Limit Lemma by a computable function where is the computable characteristic function of , the configuration of the meteorological computation at the end of time . The computable function gives an algorithm to compute the condition at time but it gives no relationship between and . It will not be possible for the meteorologist to run, let alone write a new program every second. How will the meteorologist write a program to uniformly compute the index for ?
The Online Model With an Oracle Machine
By the Shoenfield Limit Lemma there is a computably enumerable set (or even a set) and oracle machine such that . Now the meteorologist can program the algorithm into a computer once and for all at the start of the day. Every second the meteorologist receives from the weather stations the latest readings which enter directly into that computer by an network connection. The meteorologist does not (and cannot) change the program every second. The algorithm simply receives the “oracle” information from the weather-station network as it is continually updated, and computes the approximation . The meteorologist's program then produces the next scheduled weather forecast for the day from the algorithm's result. It is difficult to see how this meteorologist could have carried out that activity using a batch processing, automatic machine model, instead of an online model.
More is needed
But the forecasting program would be one of many running on the meteorologist's computer: there could be a program that uploads the resulting weather forecasts, for example, to media outlets to be broadcast to listeners or viewers. Another program could be working with devices such as:
- a screen, to view a document,
- a printer, to have a hard copy of a document,
- a speaker, to produce some sound.
Furthermore, the meteorologist may for some reason decide to intervene while those programs are running (perhaps restarting them to provide more accurate forecasts after the addition of new weather stations to the network). Given these extra requirements, will separate models be needed for each program? Or is there one model versatile enough for all of the meteorologist's programs?
An “automatic” machine becomes a “choice” machine as soon as we allow the machine’s tape to be modified by external entities: the tape itself becomes a means of communication. This is essentially what happens in “real” computers (memory-mapped I/O); for example, we can write to the computer’s screen by modifying one particular area of memory, or find out which key was pressed on the computer’s keyboard by reading another.
- Making uniqueness types less unique (page 23 of 264).
So a choice machine could merely be an automatic machine given an extra ability to make requests to external entities while it is running:
- requests for output to a screen, printer or speaker;
- or for input from a keyboard, mouse, microphone, controller, an operator or oracle.
with an oracle machine then being a specialised choice machine. Therefore if
an automatic machine computes the result of an ordinary expression (like
56 + 24
), a choice machine computes the result of an I/O action
(like getChar
) when the action is provided with an external-entity
request. So how can this concept be adapted for use in a functional
language like Haskell?
Two different approaches
Note:
- For simplicity, the examples here only gives semantics for teletype I/O.
- These are only some of the various ways to describe the semantics of
IO a
; your actual implementation may vary.
A free type
(Inspired by Luke Palmer's post.)
The idea is to define IO
as
data IO a = Done a
| PutChar Char (IO a)
| GetChar (Char -> IO a)
Think of IO a
as a tree:
PutChar
is a node that has one child tree and the node holds one character of data.GetChar
is a node that has many children; it has one child for every character, butGetChar
holds no data itself.Done a
(a leaf) is a node that holds the result of the program.
This tree contains all the information needed to execute basic interactions. One interprets (or executes) an IO a
by tracing a route from root of the tree to a leaf:
- If a
PutChar
node is encountered, the character data contained at that node is output to the terminal and then its subtree is executed. It is at this point that Haskell code is evaluated in order to determine what character should be displayed before continuing. - If a
GetChar
node is encountered, a character is read from the terminal (blocking if necessary) and the subtree corresponding to the character received is executed. - If a
Done
node is encountered, the program ends.
Done
holds the result of the computation, but in the case of Main.main :: IO ()
the data is of type ()
and thus ignored as it contains no information.
This execution is not done anywhere in a Haskell program, rather it is done by the run-time system.
The monadic operations are defined as follows:
return :: a -> IO a
return x = Done x
(>>=) :: IO a -> (a -> IO b) -> IO b
Done x >>= f = f x
PutChar c x >>= f = PutChar c (x >>= f)
GetChar g >>= f = GetChar (\c -> g c >>= f)
As you can see return
is just another name for Done
. The bind operation (>>=)
takes a tree x
and a function f
and replaces the Done
nodes (the leaves) of x
by a new tree produced by applying f
to the data held in the Done
nodes.
The primitive I/O commands are defined using these constructors.
putChar :: Char -> IO ()
putChar x = PutChar x (Done ())
getChar :: IO Char
getChar = GetChar (\c -> Done c)
- The function
putChar
builds a smallIO ()
tree that contains onePutChar
node holding the character data followed byDone
. - The function
getChar
builds a shortIO Char
tree that begins with aGetChar
node that holds oneDone
node for every character.
Other commands can be defined in terms of these primitives:
putStr :: String -> IO ()
putStr = mapM_ putChar
More generally speaking, IO a
will represent the desired interaction with the operating system. For every system call there will be a corresponding I/O-tree constructor of the form:
| SysCallName p1 p2 ... pn (r -> IO a)
where:
p1
...pn
are the parameters for the system call,- and
r
is the result of the system call.
(Thus PutChar
and GetChar
will not occur as constructors for I/O trees if they don't correspond to system calls).
A more direct style
Recalling that a choice machine computes the result of an I/O action when the action is provided an external-entity request:
data OI -- a request to an external entity
partOI :: OI -> (OI, OI) -- an I/O action requesting two more requests
getChar :: OI -> Char -- an I/O action requesting the next character of input
putChar :: Char -> -- a function expecting a character which returns
OI -> () -- an I/O action requesting the output of the given character
The action partOI :: OI -> (OI, OI)
is needed to obtain new OI
values
because each one represents a single (once-only) request to an external entity.
Hence multiple actions using the same OI
value for different requests would
be ambiguous.
In more fully-featured implementations, each system call would have its own declaration:
primitive primSysCallName :: T1 -> T2 -> ... -> OI -> Tr
foreign import ... extnSysCallName :: T1 -> T2 -> ... -> OI -> Tr
where:
T1
,T2
... are the types of the parameters for the system call,- and
Tr
is the type of the system call's result.
The type of I/O actions is easily defined:
type IO a = OI -> a . . . . | | | | an I/O | | | action | | | | | | may involve a | | request to an | | external entity | | | | when being | computed | | to obtain a result
As for the monadic interface:
instance {-# OVERLAPPING #-} Monad ((->) OI) where
return = unitOI
(>>=) = bindIO
(>>) = nextOI
unitOI :: a -> OI -> a
unitOI x = \ u -> partOI u `pseq` x
bindOI :: (OI -> a) -> (a -> OI -> b) -> OI -> b
bindOI m k = \ u -> case partOI u of (u1, u2) -> (\ x -> x `pseq` k x u2) (m u1)
nextOI :: (OI -> a) -> (IO -> b) -> OI -> b
nextOI m w = \ u -> case partOI u of (u1, u2) -> m u1 `pseq` w u2
Control.Parallel.pseq
is needed because Prelude.seq
is non-sequential, prior evidence to the contrary notwithstanding.
Further reading
- ed. Simon Marlow Marlow, 2010.
- Wouter Swierstra. Ph.D. thesis, University of Nottingham. (2009).
- Wouter Swierstra, Thorsten Altenkirch. In: Proceedings of the ACM SIGPLAN Workshop on Haskell, Haskell ’07, ACM, New York, NY, USA, pages 25–36 (2007).
- Malcolm Dowse. PhD dissertation, University of Dublin, Trinity College (2006).
- Levent Erkök, John Launchbury, Andrew Moran. In Fixed Points in Computer Science Workshop, FICS'01 (2001).
- Simon Peyton Jones. In "Engineering theories of software construction", ed. Tony Hoare, Manfred Broy, Ralf Steinbruggen, IOS Press, ISBN 1 58603 1724, 2001, pages 47-96.
- Roy L. Crole, Andrew D. Gordon. Mathematical Structures in Computer Science 9(2): 125-158 (1999).
- Philip Wadler. ACM Computing Surveys, 29(3): 240-263, September 1997.
- Andrew D. Gordon and Kevin Hammond. In: Proceedings of the Haskell Workshop, La Jolla, California, June 1995.
- Andrew Gordon. In International Workshop on Computer Science Logic, January 1995. Springer Berlin Heidelberg.
- Andrew Gordon. In FPCA '93: Conference on Functional Programming Languages and Computer Architecture, Copenhagen, June 1993. ACM Press.
- Andrew Gordon. Cambridge University Press. Revision of 1992 PhD dissertation.
- Andrew Gordon. Computer Laboratory Technical Report Number 160, University of Cambridge (1989).
- Simon Thompson. Technical Report 48, Computing Laboratory, University of Kent, Canterbury, UK, November 1987.