:- 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

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


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

ML/I

MCSET S4=1
MCNOTE Goodbye, World!

=={{header|Modula-2}}==

MODULE HelloErr;
IMPORT StdError;

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

=={{header|Modula-3}}==

MODULE Stderr EXPORTS Main;

IMPORT Wr, Stdio;

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

N/t/roff

The request .tm prints whatever after it, until and including the newline character, to the standard error. The string parsed to it need not be quoted and will never appear on standard output.

.tm Goodbye, World!

Neko

/**
  Hello world, to standard error, in Neko
  Tectonics:
    nekoc hello-stderr.neko
    neko hello-stderr
*/

/* Assume stderr is already open, just need write */
var file_write = $loader.loadprim("std@file_write", 4);

/* Load (and execute) the file_stderr primitive */
var stderr = $loader.loadprim("std@file_stderr", 0)();

file_write(stderr, "Goodbye, World!\n", 0, 16);

{{out}}

prompt$ nekoc hello-stderr.neko
prompt$ neko hello-stderr
Goodbye, World!
prompt$ neko hello-stderr 2>/dev/null
prompt$

Nemerle

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

NetRexx

/* NetRexx */

options replace format comments java crossref savelog symbols binary

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

Nim

stderr.writeln "Hello World"

=={{header|Oberon-2}}== Oxford Oberon-2

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

{{out}}

Goodbye, World!

=={{header|Objective-C}}==

{{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.

int main()
{
   fprintf(stderr, "Goodbye, World!\n");
   fputs("Goodbye, World!\n", stderr);
   NSLog(@"Goodbye, World!");
   return 0;
}

OCaml

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 [http://caml.inria.fr/pub/docs/manual-ocaml/libref/Unix.html Unix] module also provides unbuffered write functions:

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

Octave

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

Oforth

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

Ol

(print-to stderr "Goodbye, World!")

ooRexx

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

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

PARI/GP

error("Goodbye, World!")

Pascal

{{Works with|Free Pascal}}

program byeworld;

begin
  writeln(StdErr, 'Goodbye, World!');
end.

Perl

warn "Goodbye, World!\n";

Or:

print STDERR "Goodbye, World!\n";

Perl 6

note "Goodbye, World!";

Phix

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

PHP

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

or

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

PicoLisp

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

PL/I

display ('Goodbye, World');

PostScript

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

PowerBASIC

{{works with|PowerBASIC Console Compiler}}

STDERR "Goodbye, World!"

PowerShell

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

[http://www.purebasic.com/documentation/console/consoleerror.html 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 [http://www.purebasic.com/documentation/process/readprogramerror.html ReadProgramError()] to reads a line from an other programs error output (stderr).

ConsoleError("Goodbye, World!")

Python

{{works with|Python|2.x}}

import sys

print >> sys.stderr, "Goodbye, World!"

{{works with|Python|3.x}}

import sys

print("Goodbye, World!", file=sys.stderr)

Works with either:

import sys

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

R

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

Ra

class HelloWorld
	**Prints "Goodbye, World!" to standard error**

	on start

		print to Console.error made !, "Goodbye, World!"

Racket

(eprintf "Goodbye, World!\n")

Retro

'Goodbye,_World! '/dev/stderr file:spew

REXX

version 1

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

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

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

version 3

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

fputs(stderr,"Goodbye, World!")

Ruby

$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

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

fn main() {
    eprintln!("Hello, {}!", "world");
}

or

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

fn main() {
    use std::io::{self, Write};

    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!
}

=={{header|S-lang}}== () = fputs("Goodbye, World!\n", stderr);

## Salmon



```Salmon

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

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

Scala

{{libheader|Console}}

Ad hoc REPL solution

Ad hoc solution as [http://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop REPL] script:

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

Via Java runtime

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

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

Via Scala Console API

This is a call to the Scala API. '''Recommendated'''.

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

Short term deviation to err

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

Long term deviation to err

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

Scilab

error("Goodbye, World!")

Scheme

(error "Goodbye, World!")

sed

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.

{{out|Test output}}

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

Seed7

$ include "seed7_05.s7i";

const proc: main is func
  begin
    writeln(STD_ERR, "Goodbye, World!");
  end func;

Sidef

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

Slate

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

Smalltalk

The details on to which name stderr is bound may vary between Smalltalk dialects. If different, a "Smalltalk at:#Stderr put:" 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

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

Standard ML

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

Swift

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")
}

{{out}}

Goodbye, World!
Wrote 15 bytes

Tcl

puts stderr "Goodbye, World!"

=={{header|Transact-SQL}}== RAISERROR 'Goodbye, World!', 16, 1

## TUSCRIPT


```tuscript

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

{{out}}

@@@@@@@@  hello world                                                  @@@@@@@@
@@@@@@@@  goodbye world                                                @@@@@@@@

UNIX Shell

{{works with|Bourne Shell}}

echo "Goodbye, World!" >&2

=

C Shell

=

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

out "goodbye, world!" endl console.err

VBA

Sub StandardError()
    Debug.Print "Goodbye World!"
End Sub

VBScript

Must work in cscript.exe

WScript.StdErr.WriteLine "Goodbye, World!"

Verbexx

@STDERR "Goodbye, World!\n";

Visual Basic .NET

Module Module1

    Sub Main()
        Console.Error.WriteLine("Goodbye, World!")
    End Sub

End Module

WDTE

io.writeln io.stderr 'Goodbye, World!';

X86 Assembly

{{works with|nasm|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

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

XPL0

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

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