Output/Input

Clearing away the smoke and mirrors

The implementation in GHC uses the following one:

type IO a  =  World -> (a, World)

An IO computation is a function that (logically) takes the state of the world, and returns a modified world as well as the return value. Of course, GHC does not actually pass the world around; instead, it passes a dummy “token,” to ensure proper sequencing of actions in the presence of lazy evaluation, and performs input and output as actual side effects!

A History of Haskell: Being Lazy With Class, Paul Hudak, John Hughes, Simon Peyton Jones and Philip Wadler.

...so what starts out as an I/O action of type:

World -> (a, World)

is changed by GHC to approximately:

() -> (a, ())

As the returned unit-value () contains no useful information, that type can be simplified further:

() -> a

_{Why "approximately"? Because "logically" a function in Haskell has no observable effects.}

---

Previously seen

The type () -> a (or variations of it) have appeared elsewhere - examples include:

• page 2 of 13 in A Correspondence Between ALGOL 60 and Church's Lambda-Notation: Part I by Peter Landin:

The use of λ, and in particular (to avoid an irrelevant bound variable) of λ() , to delay and possibly avoid evaluation is exploited repeatedly in our model of ALGOL 60. A function that requires an argument-list of length zero is called a none-adic function. (\ () -> …) :: () -> a

• page 148 of 168 in Functional programming and Input/Output by Andrew Gordon:

abstype 'a Job = JOB of unit -> 'a data Job a = JOB (() -> a)

• page 3 of Assignments for Applicative Languages by Vipin Swarup, Uday S. Reddy and Evan Ireland:

A value of type Obs 𝜏 is called an observer. Such a value observes (i.e. views or inspects) a state and returns a value of type 𝜏. [...] An observer type Obs 𝜏 may be viewed as an implicit function space from the set of states to the type 𝜏. type Obs tau = State -> tau

• page 15 of Non-Imperative Functional Programming by Nobuo Yamashita:

type a :-> b = OI a -> b

• MTL style for free by Tom Ellis:

data Time_ a = GetCurrentTime (UTCTime -> a)

• An impure lazy programming language, also by Tom Ellis:

data IO a = IO (() -> a)

• page 2 of Unique Identifiers in Pure Functional Languages by Péter Diviánszky:

[...] The type Id can be hidden by the synonym data type :: Create a :== Id -> a type Create a = Id -> a

• page 7 of Functional Reactive Animation by Conal Elliott and Paul Hudak:

An early implementation of Fran represented behaviors as implied in the formal semantics: data Behavior a = Behavior (Time -> a)

• page 26 of How to Declare an Imperative by Philip Wadler:

The type 'a io is represented by a function expecting a dummy argument of type unit and returning a value of type 'a. type 'a io = unit -> a type Io a = () -> a

• The Haskell I/O Tutorial by Albert Lai:

But I can already tell you why we cannot follow other languages and use simply X or () -> X.

• Free Monads for Less (Part 3 of 3): Yielding IO by Edward Kmett:

newtype OI a = forall o i. OI (FFI o i) o (i -> a) deriving Functor type Oi a = forall i . i -> a

• page 27 of Purely Functional I/O in Scala by Rúnar Bjarnason:

class IO[A](run: () => A) class Io a where run :: () -> a

• igeta's snippet:

type IO<'T> = private | Action of (unit -> 'T) data IO t = Action (() -> t)

• ysdx's answer to this SO question:

Let's say you want to implement IO in SML : structure Io : MONAD = struct type 'a t = unit -> 'a ⋮ end type T a = () -> a

• luqui's answer to this SO question:

newtype IO a = IO { runIO :: () -> a }

• luqui's answer to this SO question:

newtype Supply r a = Supply { runSupply :: r -> a }

• chi's answer to this SO question:

As long as we have its special case IO c = () ~> c, we can represent (up to isomorphism) […] a ~> c […]

• Monads, I/O and Concurrency in Lux by Eduardo Julián:

(deftype #export (IO a) (-> Void a)) type IO a = (->) Void a

• Referentially Transparent Input/Output in Groovy by Mark Perry:

abstract class SimpleIO<A> { abstract A run() } class SimpleIO a where run :: () -> a

• The Observable disguised as an IO Monad by Luis Atencio:

IO is a very simple monad that implements a slightly modified version of our abstract interface with the difference that instead of wrapping a value a, it wraps a side effect function () -> a. data IO a = Wrap (() -> a)

• More Monad: IO<> Monad, from dixin's Category Theory via C# series:

The definition of IO<> is simple: public delegate T IO<out T>(); [...] IO<T> is used to represent a impure function. When a IO<T> function is applied, it returns a T value, with side effects. type IO t = () -> t

• Why suspend over IO in Arrow Fx:

[...] So suspend () -> A offers us the exact same guarantees as IO<A>.

Of these, it is the implementation of OI a in Yamashita's oi package which is most interesting as its values are monousal - once used, their contents remain constant. This single-use property also appears in the implementation of the abstract decision type described by F. Warren Burton in Nondeterminism with Referential Transparency in Functional Programming Languages.

---

IO, redefined

Based on these and other observations, a reasonable distillment of these examples would be OI -> a, which then implies:

type IO a = OI -> a

Using Burton's pseudodata approach:

 -- abstract; single-use I/O-access mediator
data Exterior
getchar :: Exterior -> Char
putchar :: Char -> Exterior -> ()

 -- from section 2 of Burton's paper
data Tree a = Node { contents :: a,
                     left     :: Tree a,
                     right    :: Tree a }

 -- utility definitions
type OI  =  Tree Exterior

getChar' :: OI -> Char
getChar' =  getchar . contents

putChar' :: Char -> OI -> ()
putChar' c = putchar c . contents

part     :: OI -> (OI, OI)
parts    :: OI -> [OI]

part t   =  (left t, right t)
parts t  =  let !(t1, t2) = part t in
            t1 : parts t2

Of course, in an actual implementation OI would be abstract like World, and for similar reasons. This permits a simpler implementation for OI and its values, instead of being based on (theoretically) infinite structured values like binary trees. That simplicity has benefits for the OI interface, in this case:

data OI
part :: OI -> (OI, OI)
getChar' :: OI -> Char
putChar' :: Char -> OI -> ()

---

See also

• Monadic IO in Standard ML
• Disposing of dismissives
• IO then abstraction
• The IO monad in 1965