Hello world that handles errors

Question

Write a program or function with the following functionality:

• The program/function first attempts to write the string Hello, world! to the standard output stream. (No other forms of output are acceptable for this challenge, as the focus is very much on the I/O rather than the trivial behaviour of the program itself.) Depending on whether it succeeded:
  • If it succeeded in outputting Hello, world!, the program/function exits without any further behaviour.
  • If it failed to produce the correct output due to an error, the program/function attempts to write the string Error writing "Hello, world!" to the standard error stream. (For the purposes of this challenge, you don't need error handling for the error handling itself.)

Clarifications

• Your program/function will be run with no input (unless it's written in a language which absolutely requires input to work, in which case it will be run with the simplest possible input).

• When producing output, you may also produce a single trailing newline if you wish, but doing so is not mandatory.

• The definition of "error writing to standard output" that your program implements must treat at least the following cases as errors:

  • Standard output being nonexistent (i.e. stdout is a closed filehandle, no file descriptor 1 exists, or however those cases translate to the language and OS you're using);
  • Standard output referring to a file on a disk that has no free space left;
  • Standard output connecting to another program, which has already closed its end of the connection.

  and must treat at least the following cases as success (i.e. not an error):

  • Standard output connects to a terminal, and Hello, world! is displayed onscreen.
  • Standard output connects to a file, and Hello, world! is written into the file.

  You can choose the details of what counts as an output error, so long as it's consistent with the above rules.

• Your program/function should not crash upon encountering any of the error situations listed above. It's up to you what exit code you use.

• Your program/function should not describe the nature of the encountered error on the standard error stream; it should just print the string specified above. Extraneous output on standard error (e.g. compiler warnings) is only legal if it's produced unconditionally, regardless of whether an error is encountered or not.

• Your program only needs to work on one operating system (although it must be one on which the errors listed above make sense; I've tried to keep them general enough to work on most multitasking consumer operating systems, but weirder operating systems may well be excluded from this challenge). If your program is nonportable, list the assumptions it needs to run in the title of your submission.

• This task may not be possible in every language (not every language allows a program to handle output errors in a custom way). You'll have to pick a language where it is possible.

• Make sure that your program/function works! Don't just trust the documentation of library functions to do what they say they do. The error handling of simple output functions often turns out to be broken in practice, even if the functions claim to handle errors in theory.

Test cases

Here's a way to simulate each of the error conditions above using bash on Linux (you don't have to use Linux, but it's likely the easiest system to test this on):

your_program_here >&-           # nonexistent stdout
your_program_here > /dev/full   # out of disk space
mkfifo test  # note: change "test" to a filename that isn't in use
true < test &
your_program_here > test        # connecting to a program that doesn't want input
rm test      # clean up the FIFO we used earlier

The first two testcases are deterministic. The last isn't (it relies on a race condition); for testing purposes, I recommend adding a delay between the start of your program and the actual output to standard output, in order to ensure that the race condition is resolved in the way that exposes the error.

Victory condition

This is a code-golf challenge, so shorter is better. As (nearly) always, we're measuring the length of the program in bytes.

Answer 1

Bash, 71 60 bytes

h=Hello,\ world!
(echo $h)2>&-||echo Error writing \"$h\">&2

Try it online!

How it works

After saving Hello, world! to the variable h, we do the following.

First, (echo $h)2>&- attempts to print Hello, world! to STDOUT. 2>&- is required to prevent displaying the error message echo: write error: Bad file descriptor in case the write fails. Since writing to a named pipe that doesn't accept input would kill the Bash program with signal 13 (SIGPIPE), we execute the command in a subshell ((...)), so only the subshell will get killed.

Finally, if printing to STDOUT failed, the subshell will exit with a non-zero status code (141 for SIGPIPE, 1 for a generic error), so echo Error writing \"$h\">&2 prints the desired message to STDERR.

Answer 2

Python 2, 65 bytes

h='Hello, world!'
try:print h
except:exit('Error writing "%s"'%h)

Two bytes could be saved by printing single quotes.

Try it online!

Answer 3

Zsh, 55 bytes

h=Hello,\ world!
2>&-<<<$h||<<<'Error writing "'$h\">&2

Unlike its cousin Bash, Zsh refuses to die because of a broken pipe.

Try it online!

Answer 4

Javascript, 79 76 bytes

try{(l=console).log(a="Hello, world!")}catch(e){l.error('Error writing '+a)}

Answer 5

PowerShell, 80 Bytes

try{echo($h="Hello, World!") -ea 4}catch{$host.ui|% *rL* "Error writing ""$h"""}

explained:

try{
    #Attempt to 'echo' (write output) the string, and assign it to $h
    #Make sure the 'error action' is set to '4' to make it a terminating error.
    echo($h="Hello, World!") -ea 4
} catch { 
    #Use the "WriteErrorLine" function in $host.ui to stderr
    $host.ui|% *rL* "Error writing ""$h"""
}

haven't managed to actually try this when it errors, but it definitely ~should~ work.

Answer 6

C (gcc), 87 86 bytes

f(){signal(13,1);write(1-puts("Hello, world!"),"Error writing \"Hello, world!\"",29);}

Try it online!

Ungolfed

#include <signal.h>
#include <stdio.h>
#include <unistd.h>

void f(void)
{
    signal(SIGPIPE, SIG_IGN); // Works (and is required) on TIO. YMMV
    int fd = (puts("Hello, world!")) < 0 ? 2 : -13;
    write(fd, "Error writing \"Hello, world!\"", 29);
}

Answer 7

Perl 5, 51 bytes

requires -M5.01, which is free

say$h="Hello, world!"or die"Error writing \"$h\"$/"

Tested in Strawberry Perl 5.24.0 by running the program as-is (printed to standard output) and by running

print f $h="Hello, world!"or die"Error writing \"$h\"$/"

(printed to standard error). I don't know how to test for other errors using Strawberry, but they should be handled the same….

Answer 8

REXX, 111 106 bytes

signal on notready
a='Hello, world!'
_=lineout(,a)
exit
notready:_=lineout('stderr','Error writing "'a'"')

The program relies on there being a stream called 'stderr'. This will probably not be the case on IBM systems.

Answer 9

C, 77 bytes

f(a){a="Error writing \"Hello, world!\"";write(1,a+15,13)-13&&write(2,a,29);}

for call

main(){f(1); return 0;}

Answer 10

R, 91 bytes

s="Hello, world!"
tryCatch(cat(s),error=function(e)cat('Error writing "','"',file=2,sep=s))

Try it online!

I tried erroring it by running it with cat(s,file=12) instead of cat(s), and it prints the correct text to stderr. This is an invalid connection error otherwise.