Hello world/Standard error

From Rosetta Code
Task
Hello world/Standard error
You are encouraged to solve this task according to the task description, using any language you may know.
Hello world/Standard error is part of Short Circuit's Console Program Basics selection.

A common practice in computing is to send error messages to a different output stream than normal text console messages.

The normal messages print to what is called "standard output" or "standard out".

The error messages print to "standard error".

This separation can be used to redirect error messages to a different place than normal messages.


Task

Show how to print a message to standard error by printing     Goodbye, World!     on that stream.

4DOS Batch[edit]

echoerr Goodbye, World!

Ada[edit]

with Ada.Text_IO;  use Ada.Text_IO;
 
procedure Goodbye_World is
begin
Put_Line (Standard_Error, "Goodbye, World!");
end Goodbye_World;

Agena[edit]

io.write( io.stderr, "Goodbye, World!\n" )

Aime[edit]

v_text("Goodbye, World!\n");

ALGOL 68[edit]

The procedures print and printf output to stand out, whereas put and putf can output to any open file, including stand error.

Works with: ALGOL 68 version Revision 1 - no extensions to language used
Works with: ALGOL 68G version Any - tested with release 1.18.0-9h.tiny
Works with: ELLA ALGOL 68 version Any (with appropriate job cards) - tested with release 1.8-8d - note that printf and putf were not ported into ELLA's libraries.
main:(
put(stand error, ("Goodbye, World!", new line))
)
Output:
Goodbye, World!

Argile[edit]

use std
eprint "Goodbye, World!"

or

use std
eprintf "Goodbye, World!\n"

or

use std
fprintf stderr "Goodbye, World!\n"

ATS[edit]

implement main0 () = fprint (stderr_ref, "Goodbye, World!\n")

AutoHotkey[edit]

requires AutoHotkey_N implementation.

; c:\>  autohotkey.exe stderr.ahk 2> error.txt
FileAppend, Goodbye`, World!, stderr ; requires AutoHotkey_N

Or with the current AutoHotkey_L:

Works with: AutoHotkey_L

(documentation on this behavior: http://www.autohotkey.net/~Lexikos/AutoHotkey_L/docs/commands/FileAppend.htm)

FileAppend, Goodbye`, World!, *

AutoIt[edit]

ConsoleWriteError("Goodbye, World!" & @CRLF)

AWK[edit]

To print a message to standard error, pipe it through a shell command:

BEGIN {
print "Goodbye, World!"| "cat 1>&2"
}

Or write to /dev/stderr:

Works with: gawk
Works with: mawk
Works with: nawk
BEGIN {
print "Goodbye, World!" > "/dev/stderr"
}

With gawk, mawk and nawk: a special feature associates "/dev/stderr" with standard error. The manuals of gawk and mawk describe this feature; nawk also has this feature.

Other implementations might try to open /dev/stderr as a file. Some Unix clones, like BSD, have a /dev/stderr device node that duplicates standard error, so this code would still work. Some systems have no such device node, so this code would fail. We recommend "cat 1>&2", which is more portable, and works with any Unix clone.

BASIC[edit]

BaCon[edit]

EPRINT "Goodbye, World!"

ZX Spectrum Basic[edit]

On the ZX Spectrum, standard error is on stream 1:

 
10 PRINT #1;"Goodbye, World!"
20 PAUSE 50: REM allow time for the user to see the error message
 

Batch File[edit]

1>&2 echo Goodbye, World!

The redirection operator 1>&2 causes all output on stream 1 (standard out) to be redirected to stream 2 (standard error). The redirection can be moved to the end of the line, too.

BBC BASIC[edit]

The program must be compiled as a console application for this to work.

      STD_ERROR_HANDLE = -12
SYS "GetStdHandle", STD_ERROR_HANDLE TO @hfile%(1)
PRINT #13, "Goodbye, World!"
QUIT

C[edit]

Unlike puts(), fputs() does not append a terminal newline.

#include <stdio.h>
 
int main()
{
fprintf(stderr, "Goodbye, ");
fputs("World!\n", stderr);
 
return 0;
}

C#[edit]

static class StdErr
{
static void Main(string[] args)
{
Console.Error.WriteLine("Goodbye, World!");
}
}

C++[edit]

#include <iostream>
 
int main () {
std::cerr << "Goodbye, World!" << std::endl;
}

Clojure[edit]

(binding [*out* *err*]
(println "Goodbye, world!"))

CMake[edit]

Most messages go to standard error.

message("Goodbye, World!")

The message cannot be a keyword; message("STATUS") never prints "STATUS", but message("" "STATUS") does work.

COBOL[edit]

Using fixed format.

Works with: OpenCOBOL
	program-id. ehello.
procedure division.
display "Goodbye, world!" upon syserr.
stop run.

CoffeeScript[edit]

Translation of: JavaScript
Works with: Node.js
console.warn "Goodbye, World!"

Common Lisp[edit]

(format *error-output* "Goodbye, world!~%")

D[edit]

import std.stdio;
 
void main () {
stderr.writeln("Goodbye, World!");
}

Alternative Version[edit]

Library: tango
import tango.io.Stdout;
 
void main () {
Stderr("Goodbye, World!").newline;
}

Déjà Vu[edit]

!write-fragment!stderr !encode!utf-8 "Goodbye, World!\n"

Delphi[edit]

program Project1;
 
{$APPTYPE CONSOLE}
 
begin
WriteLn(ErrOutput, 'Goodbye, World!');
end.

Dylan.NET[edit]

Works with: Mono version 2.6.7
Works with: Mono version 2.10.x
Works with: Mono version 3.x.y
Works with: .NET version 3.5
Works with: .NET version 4.0
Works with: .NET version 4.5

One Line version:

Console::get_Error()::WriteLine("Goodbye World!")

Goodbye World Program:

 
//compile using the new dylan.NET v, 11.5.1.2 or later
//use mono to run the compiler
#refstdasm mscorlib.dll
 
import System
 
assembly stderrex exe
ver 1.1.0.0
 
class public Program
 
method public static void main()
Console::get_Error()::WriteLine("Goodbye World!")
end method
 
end class
 

E[edit]

stderr.println("Goodbye, World!")

Elixir[edit]

IO.puts :stderr, "Goodbye, World!"

Emacs Lisp[edit]

 
(error "Goodbye, World!")
 

Output:

Goodbye, World!                                                                              

Erlang[edit]

io:put_chars(standard_error, "Goodbye, World!\n").

Euphoria[edit]

puts(2,"Goodbye, world!\n") -- 2 means output to 'standard error'

F#[edit]

eprintfn "%s" "Goodbye, World!"

or you can use the .Net classes

System.Console.Error.WriteLine("Goodbye, World!");

Factor[edit]

Start Factor in a terminal for this:

error-stream get [ "Goodbye, World! bbl, crashing" print flush ] with-output-stream*

Fantom[edit]

 
class Main
{
public static Void main ()
{
Env.cur.err.printLine ("Goodbye, World!")
}
}
 

Forth[edit]

Works with: GNU Forth
outfile-id
stderr to outfile-id
." Goodbye, World!" cr
to outfile-id

Fortran[edit]

Normally standard error is associated with the unit 0 but this could be different for different vendors. Therefore since Fortran 2003 there's an intrinsic module which defines the parameter ERROR_UNIT.

program StdErr
! Fortran 2003
use iso_fortran_env
 
! in case there's no module iso_fortran_env ...
!integer, parameter :: ERROR_UNIT = 0
 
write (ERROR_UNIT, *) "Goodbye, World!"
end program StdErr

FreeBASIC[edit]

' FB 1.05.0 Win64
 
Open Err As #1
Print #1, "Goodbye World!"
Close #1
Sleep

Frink[edit]

 
staticJava["java.lang.System","err"].println["Goodbye, World!"]
 

Go[edit]

Built in println now goes to stderr.

package main
func main() { println("Goodbye, World!") }

but the builtin print() and println() functions are not guaranteed to stay in the language. So you should probably use

package main
import ("fmt"; "os")
func main() { fmt.Fprintln(os.Stderr, "Goodbye, World!") }

Groovy[edit]

System.err.println("Goodbye, World!")

Haskell[edit]

import System.IO
main = hPutStrLn stderr "Goodbye, World!"

Icon and Unicon[edit]

procedure main()
write(&errout, "Goodbye World" )
end

J[edit]

stderr =: 1!:2&4
stderr 'Goodbye, World!'

Java[edit]

public class Err{
public static void main(String[] args){
System.err.println("Goodbye, World!");
}
}

JavaScript[edit]

Works with: JScript
and only with cscript.exe
WScript.StdErr.WriteLine("Goodbye, World!");
Works with: Node.js
console.warn("Goodbye, World!")
Works with: Firefox
console.error("Goodbye, World!")//only works if console object exists

OR

throw new Error("Goodbye, World!")//Should work in any browser

jq[edit]

error("Goodbye, World!")

Note that although this satisfies the task requirement, error/1 also raises an error condition.

Julia[edit]

println(STDERR, "Goodbye, World!")

Kotlin[edit]

// version 1.0.6
 
fun main(args: Array<String>) {
System.err.println("Goodbye, World!")
}

Lasso[edit]

define stderr(s::string) => {
file_stderr->writeBytes(#s->asBytes)
}
 
stderr('Goodbye, World!')

Lingo[edit]

  • Windows:
-- print to standard error
stdErr("Goodbye, World!", TRUE)
 
-- print to the Windows debug console (shown in realtime e.g. in Systernal's DebugView)
dbgPrint("Goodbye, World!")
  • Mac OS X:
Library: Shell Xtra
sx = xtra("Shell").new()
 
-- print to standard error
sx.shell_cmd("echo Goodbye, World!>&2")
 
-- print to system.log (shown in realtime e.g. in Konsole.app)
sx.shell_cmd("logger Goodbye, World!")

Logtalk[edit]

The stream alias "user_error" can be used to print to the "standard error" stream.

 
:- object(error_message).
 
% the initialization/1 directive argument is automatically executed
% when the object is compiled and loaded into memory:
:- initialization(write(user_error, 'Goodbye, World!\n')).
 
:- end_object.
 

Lua[edit]

io.stderr:write("Goodbye, World!\n")

m4[edit]

errprint(`Goodbye, World!
')dnl

Mathematica / Wolfram Language[edit]

Write[Streams["stderr"], "Goodbye, World!"]

MATLAB / Octave[edit]

This prints to standard error, and continues execution

fprintf(2,'Goodbye, World!')

This will not stop further execution, if called from within a script or function.

error 'Goodbye, World!'

Mercury[edit]

 
:- module hello_error.
:- interface.
 
:- import_module io.
:- pred main(io::di, io::uo) is det.
 
:- implementation.
 
main(!IO) :-
io.stderr_stream(Stderr, !IO),
io.write_string(Stderr, "Goodbye, World!\n", !IO).
 

Metafont[edit]

Metafont has no a real way to send a text to the standard output/error nor to a file. Anyway it exists the errmessage command which will output an error message and prompt the user for action (suspending the interpretation of the source).

errmessage "Error";
message "...going on..."; % if the user decides to go on and not to stop
 % the program because of the error.

ML/I[edit]

MCSET S4=1
MCNOTE Goodbye, World!

Modula-2[edit]

MODULE HelloErr;
IMPORT StdError;
 
BEGIN
StdError.WriteString('Goodbye, World!');
StdError.WriteLn
END HelloErr.

Modula-3[edit]

MODULE Stderr EXPORTS Main;
 
IMPORT Wr, Stdio;
 
BEGIN
Wr.PutText(Stdio.stderr, "Goodbye, World!\n");
END Stderr.

Nemerle[edit]

System.Console.Error.WriteLine("Goodbye, World!");

NetRexx[edit]

/* NetRexx */
 
options replace format comments java crossref savelog symbols binary
 
System.err.println("Goodbye, World!")
 

Nim[edit]

stderr.writeln "Hello World"

Oberon-2[edit]

Oxford Oberon-2

 
MODULE HelloErr;
IMPORT Err;
BEGIN
Err.String("Goodbye, World!");Err.Ln
END HelloErr.
 
Output:
Goodbye, World!

Objective-C[edit]

Works with: GNUstep
Works with: Cocoa

In Objective-C one can use the standard C library and the stderr as in the C language; nonetheless a common way to output to stderr for logging purpose and/or error notification is the NSLog function, that works almost like fprintf(stderr, "..."), save for the fact that the format string is an NSString object, and it also prepends a timestamp.

#import <Foundation/Foundation.h>
 
int main()
{
fprintf(stderr, "Goodbye, World!\n");
fputs("Goodbye, World!\n", stderr);
NSLog(@"Goodbye, World!");
return 0;
}

OCaml[edit]

prerr_endline "Goodbye, World!";    (* this is how you print a string with newline to stderr *)
Printf.eprintf "Goodbye, World!\n"; (* this is how you would use printf with stderr *)

we can also use the out_channel stderr:

output_string stderr "Goodbye, World!\n";
Printf.fprintf stderr "Goodbye, World!\n";

finally the Unix module also provides unbuffered write functions:

let msg = "Goodbye, World!\n" in
ignore(Unix.write Unix.stderr msg 0 (String.length msg)) ;;

Octave[edit]

fprintf(stderr, "Goodbye, World!\n");

Oforth[edit]

System.Err "Goodbye, World!" << cr

ooRexx[edit]

ooRexx provides a .error object that writes output to the standard error stream.

.error~lineout("Goodbye, World!")

The .error object is a proxy that delegates to a backing stream, so this might be redirected. By default, this delegates to the .stderr object, which can also be used directly.

.stderr~lineout("Goodbye, World!")

or in 'Classic REXX style'

/* REXX ---------------------------------------------------------------
* 07.07.2014 Walter Pachl
* 12.07.2014 WP see Discussion where redirection from within the program is shown
*--------------------------------------------------------------------*/

Say 'rexx serr 2>err.txt directs the stderr output to the file err.txt'
Call lineout 'stderr','Good bye, world!'
Call lineout ,'Hello, world!'
Say 'and this is the error output:'
'type err.txt'

Oz[edit]

functor
import Application System
define
{System.showError "Goodbye, World!"}
{Application.exit 0}
end

PARI/GP[edit]

error("Goodbye, World!")

Pascal[edit]

Works with: Free Pascal
program byeworld;
 
begin
writeln(StdErr, 'Goodbye, World!');
end.

Perl[edit]

warn "Goodbye, World!\n";

Or:

print STDERR "Goodbye, World!\n";

Perl 6[edit]

note "Goodbye, World!";

Phix[edit]

puts(2,"Goodbye, World!\n")

PHP[edit]

fprintf(STDERR, "Goodbye, World!\n");

or

file_put_contents("php://stderr","Hello World!\n");

PicoLisp[edit]

(out 2 (prinl "Goodbye, World!"))

PL/I[edit]

display ('Goodbye, World');

PostScript[edit]

(%stderr) (w) file dup
(Goodbye, World!
) writestring
closefile

PowerBASIC[edit]

STDERR "Goodbye, World!"

PowerShell[edit]

Since PowerShell has a slightly different system of pipes and streams (to facilitate easy usage from a host application) the standard Write-Error cmdlet is mainly for sending annotated error messages to the host:

Write-Error "Goodbye, World!"

Note that this outputs more than just the message, because behind the scenes it is an uncaught exception:

Write-Error "Goodbye, World!" : Goodbye, World!
    + CategoryInfo          : NotSpecified: (:) [Write-Error], WriteErrorException
    + FullyQualifiedErrorId : Microsoft.PowerShell.Commands.WriteErrorException

To accurately reproduce the behavior of other languages one has to resort to .NET in this case:

[Console]::Error.WriteLine("Goodbye, World!")

PureBasic[edit]

ConsoleError() writes the message string (plus a newline) to the standard error output of current program.

Standard error output can be used in conjunction with ReadProgramError() to reads a line from an other programs error output (stderr).

ConsoleError("Goodbye, World!")

Python[edit]

Works with: Python version 2.x
import sys
 
print >> sys.stderr, "Goodbye, World!"
Works with: Python version 3.x
import sys
 
print("Goodbye, World!", file=sys.stderr)

Works with either:

import sys
 
sys.stderr.write("Goodbye, World!\n")

R[edit]

cat("Goodbye, World!", file=stderr())

Ra[edit]

 
class HelloWorld
**Prints "Goodbye, World!" to standard error**
 
on start
 
print to Console.error made !, "Goodbye, World!"
 

Racket[edit]

 
(eprintf "Goodbye, World!\n")
 

Retro[edit]

with files'
"Goodbye, World!" tempString dup getLength "/dev/stderr" spew

REXX[edit]

version 1[edit]

This version will work with those operating systems (hosts) that support stream output and a STDERR output
stream (by name).
If the   stderr   name is supported and enabled, the output is written to the terminal.
If not supported or disabled, the output is written to a (disk) file named   STDERR.

call lineout 'STDERR', "Goodbye, World!"

version 2[edit]

Same as above, but uses a different style and also invokes   charout   instead of   lineout.

msgText = 'Goodbye, World!'
call charout 'STDERR', msgText

version 3[edit]

this works on Windows 7 and ooRexx and REGINA

/* REXX ---------------------------------------------------------------
* 07.07.2014 Walter Pachl
* enter the appropriate command shown in a command prompt.
* "rexx serr.rex 2>err.txt"
* or "regina serr.rex 2>err.txt"
* 2>file will redirect the stderr stream to the specified file.
* I don't know any other way to catch this stream
*--------------------------------------------------------------------*/

Parse Version v
Say v
Call lineout 'stderr','Good bye, world!'
Call lineout ,'Hello, world!'
Say 'and this is the error output:'
'type err.txt'

Ring[edit]

fputs(stderr,"Goodbye, World!")

Ruby[edit]

$stderr.puts "Goodbye, World!"

The following also works, unless you have disabled warnings (ruby command line option "-W0" or set $VERBOSE=nil)

warn "Goodbye, World!"

Run BASIC[edit]

html "<script>
window.open('','error_msg','');
document.write('Goodbye, World!');
</script>""

Run Basic runs in a browser. This opens a new browser window, or a tab in the case of Chrome and some others.

Rust[edit]

► Run this code

fn main() {
use ::std::io::Write;
let (stderr, errmsg) = (&mut ::std::io::stderr(), "Error writing to stderr");
writeln!(stderr, "Bye, world!").expect(errmsg);
 
let (goodbye, world) = ("Goodbye", "world");
writeln!(stderr, "{}, {}!", goodbye, world).expect(errmsg);
}

or

 use std::io::{self, Write};
fn main() {
io::stderr().write(b"Goodbye, world!").expect("Could not write to stderr");
// With some finagling, you can do a formatted string here as well
let goodbye = "Goodbye";
let world = "world";
io::stderr().write(&*format!("{}, {}!", goodbye, world).as_bytes()).expect("Could not write to stderr");
// Clearly, if you want formatted strings there's no reason not to just use writeln!
}

S-lang[edit]

() = fputs("Goodbye, World!\n", stderr);

Salmon[edit]

 
standard_error.print("Goodbye, World!\n");
 

or

 
include "short.salm";
stderr.print("Goodbye, World!\n");
 

or

 
include "shorter.salm";
err.print("Goodbye, World!\n");
 

or

 
include "shorter.salm";
se.print("Goodbye, World!\n");
 

Sather[edit]

class MAIN is
main is
#ERR + "Hello World!\n";
end;
end;

Scala[edit]

Library: Console

Ad hoc REPL solution[edit]

Ad hoc solution as REPL script:

Console.err.println("Goodbye, World!")

Via Java runtime[edit]

This is a call to the Java run-time library. Not recommendated.

System.err.println("Goodbye, World!")

Via Scala Console API[edit]

This is a call to the Scala API. Recommendated.

Console.err.println("Goodbye, World!")

Short term deviation to err[edit]

Console.withOut(Console.err) { println("This goes to default _err_") }

Long term deviation to err[edit]

  println ("Out not deviated")
Console.setOut(Console.err)
println ("Out deviated")
Console.setOut(Console.out) // Reset to normal

Scilab[edit]

error("Goodbye, World!")

Scheme[edit]

(error "Goodbye, World!")

sed[edit]

Requires /dev/stderr

#n
1 {
s/.*/Goodbye, World!/w /dev/stderr
}

This program requires at least 1 line of input. It changes the first line to "Goodbye, World!" and then prints the first line to standard error. It reads and ignores the remaining lines.

Test output:
$ echo a | sed -f error.sed >/dev/null
Goodbye, World!

Seed7[edit]

$ include "seed7_05.s7i";
 
const proc: main is func
begin
writeln(STD_ERR, "Goodbye, World!");
end func;

Sidef[edit]

STDERR.println("Goodbye, World!");

Slate[edit]

inform: 'Goodbye, World!' &target: DebugConsole.

Smalltalk[edit]

The details on to which name stderr is bound may vary between Smalltalk dialects. If different, a "Smalltalk at:#Stderr put:<name your stream here>" should provide compatibility.

Stderr nextPutAll: 'Goodbye, World!'

However, all smalltalks provide a console named "Transcript", where diagnostics is usually sent to. Thus:

Transcript show: 'Goodbye, World!'

will work on all, and is the preferred way to do this. And yes, when operating UI-less, the global "Transcript" is usually bound to the stderr stream.

SNOBOL4[edit]

        terminal = "Error"
output = "Normal text"
end

Standard ML[edit]

TextIO.output (TextIO.stdErr, "Goodbye, World!\n")

Swift[edit]

import Foundation
 
let out = NSOutputStream(toFileAtPath: "/dev/stderr", append: true)
let err = "Goodbye, World!".dataUsingEncoding(NSUTF8StringEncoding, allowLossyConversion: false)
out?.open()
let success = out?.write(UnsafePointer<UInt8>(err!.bytes), maxLength: err!.length)
out?.close()
 
if let bytes = success {
println("\nWrote \(bytes) bytes")
}
Output:
Goodbye, World!
Wrote 15 bytes

Tcl[edit]

puts stderr "Goodbye, World!"

Transact-SQL[edit]

 RAISERROR 'Goodbye, World!', 16, 1 

TUSCRIPT[edit]

 
$$ MODE TUSCRIPT
PRINT/ERROR "hello world"
text="goodbye world"
PRINT/ERROR text
 
Output:
@@@@@@@@  hello world                                                  @@@@@@@@
@@@@@@@@  goodbye world                                                @@@@@@@@

UNIX Shell[edit]

Works with: Bourne Shell
echo "Goodbye, World!" >&2

C Shell[edit]

echo "Goodbye, World!" >/dev/stderr

This requires /dev/stderr, a device node from BSD and some other Unix clones. This command works with both Bourne Shell and C Shell.

Ursa[edit]

out "goodbye, world!" endl console.err

VBScript[edit]

Must work in cscript.exe

WScript.StdErr.WriteLine "Goodbye, World!"

X86 Assembly[edit]

Works with: nasm version 2.05.01

This is known to work on Linux, it may or may not work on other Unix-like systems

Note that it is only 2 characters different from the Assembly example on User Output - text

Prints "Goodbye, World!" to stderr (and there is probably an even simpler version):

section .data
msg db 'Goodbye, World!', 0AH
len equ $-msg
 
section .text
global _start
_start: mov edx, len
mov ecx, msg
mov ebx, 2
mov eax, 4
int 80h
 
mov ebx, 1
mov eax, 1
int 80h

XLISP[edit]

(DISPLAY "Goodbye, World!" *ERROR-OUTPUT*)

XPL0[edit]

The terms "standard output" and "standard error" are not used, but it's trivial to send messages to a variety of devices by specifying their numbers. Normally messages are displayed on the text console, which is device 0. Instead, this example sends the message to the (first) printer, which is device 2.

code Text=12;
Text(2, "Goodbye, World!")

zkl[edit]

File.stderr.writeln("Goodbye, World!")