Hello world/Newline omission: Difference between revisions
m
syntax highlighting fixup automation
(Blade) |
Thundergnat (talk | contribs) m (syntax highlighting fixup automation) |
||
Line 16:
=={{header|11l}}==
<
=={{header|68000 Assembly}}==
Line 22:
Code is called as a subroutine, taking <code>A0</code> as its argument (e.g. <code>LEA myString,A0 JSR PrintString</code>). The hardware-specific <code>PrintChar</code> routine is left unimplemented.
<
;input: A0 = source address
;outputs to screen.
Line 39:
myString:
DC.B "Goodbye, World!",0
EVEN</
=={{header|ACL2}}==
<
=={{header|Action!}}==
<
Print("Goodbye, World!")
RETURN</
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Newline_omission.png Screenshot from Atari 8-bit computer]
Line 56:
=={{header|Ada}}==
This example will implicitly include a final, implementation defined, terminator (usually a linefeed) if the output is a file (RM A.10.7-8) such as <code>stdout</code> on UNIX systems.
<
with Ada.Text_IO;
Line 63:
Ada.Text_IO.Put("Goodbye, World!");
end Goodbye_World;
</syntaxhighlight>
Using <code>Ada.Text_IO.Text_Streams</code> instead allows us to control the termination.
<
with Ada.Text_IO;
with Ada.Text_IO.Text_Streams;
Line 74:
String'Write(Ada.Text_IO.Text_Streams.Stream(stdout), "Goodbye World");
end Goodbye_World;
</syntaxhighlight>
=={{header|Agena}}==
<
=={{header|ALGOL 68}}==
This works with Algol68 Genie 2.8.2 and above. Earlier versions appended a gratuitous newline on unflushed output when the program terminated.
<
print ("Goodbye, World!")
END</
=={{header|Arturo}}==
<
{{out}}
Line 93:
=={{header|ATS}}==
<
=={{header|AutoHotkey}}==
<
FileAppend, Goodbye`, World!, CONOUT$ ; No newline outputted
MsgBox</
=={{header|AutoIt}}==
<syntaxhighlight lang="autoit">
ConsoleWrite("Goodbye, World!")
</syntaxhighlight>
=={{header|AWK}}==
<syntaxhighlight lang="awk">
BEGIN { printf("Goodbye, World!") }
</syntaxhighlight>
=={{header|Axe}}==
<
=={{header|B}}==
{{works with|The Amsterdam Compiler Kit - B|V6.1pre1}}
<
{
putstr("Goodbye, World!");
return(0);
}</
=={{header|BASIC}}==
<
20 PRINT "Goodbye, World!";</
==={{header|BaCon}}===
BaCon supports BASIC PRINT ending with trailing semicolon to prevent a newline and also supports a FORMAT clause that uses ''printf'' specifications and special character escapes (with no \n, there is no newline).
<
PRINT "Goodbye, World!" FORMAT "%s"</
==={{header|Applesoft BASIC}}===
<
==={{header|Commodore BASIC}}===
<
20 print "Goodbye, World!";
30 rem * If we end this program here, we will not see the effect because
Line 140:
50 rem * So, we just print additional message...
60 print "(End of the world)"
70 end</
'''Output:'''
<pre>
Line 150:
==={{header|BASIC256}}===
Output all on a single line.
<
print " ";
print "World!";</
==={{header|IS-BASIC}}===
<
==={{header|QBasic}}===
Line 162:
{{works with|Yabasic}}
A trailing semicolon prevents a newline
<
END</
==={{header|True BASIC}}===
Line 170:
{{works with|Yabasic}}
A trailing semicolon prevents a newline
<
END</
==={{header|Yabasic}}===
Line 178:
{{works with|True BASIC}}
A trailing semicolon prevents a newline
<
end</
=={{header|Batch File}}==
'''Under normal circumstances, when delayed expansion is disabled'''<br/>
The quoted form guarantees there are no hidden trailing spaces after World!
<
<nul set/p=Goodbye, World!</
'''If delayed expansion is enabled, then the ! must be escaped'''<br/>
Escape once if quoted form, twice if unquoted.
<
<nul set/p"=Goodbye, World^!"
<nul set/p=Goodbye, World^^^!</
=={{header|BBC BASIC}}==
<
PRINT "Goodbye World!";
Line 201:
FOR i% = 1 TO LEN(GW$)
VDU ASCMID$(GW$, i%)
NEXT</
=={{header|Bc}}==
<
=={{header|beeswax}}==
<syntaxhighlight lang
beeswax prints everything without appending a newline character. beeswax has an instruction to explicitely print a newline character: <code>N</code>.
Line 214:
In Befunge, a newline has to be explicitly output when required, so you can just not include one if it's not wanted.
<
=={{header|Blade}}==
<syntaxhighlight lang
=={{header|bootBASIC}}==
"Goodbye, w" and "orld!" are printed on different lines because not enough characters are allowed per line to complete this task in one line, even for the most code golfed version.
<
20 print "orld!";</
=={{header|Bracmat}}==
<
=={{header|Brainf***}}==
One option was to copy the code from the regular Hello World version and omit the last period, but one of the nicer things about the language is that no matter how simple your program is, if it's more than a few characters long, it's probably unique. So here's yet another version of Goodbye, World in Brainf***.
<
+.>>+..<.--.++>>+.<<+.>>>-.>++.[<]++++[>++++<-]>.>>.+++.------.<-.[>]<+.[-]
[G oo d b y e , W o r l d !]</
=={{header|C}}==
In C, we do not get a newline unless we embed one:
<
#include <stdlib.h>
Line 242:
(void) printf("Goodbye, World!"); /* No automatic newline */
return EXIT_SUCCESS;
}</
However ISO C leaves it up to implementations to define whether or not the last line of a text stream requires a new-line. This means that the C can be targetted to environments where this task is impossible to implement, at least with a direct text stream manipulation like this.
=={{header|C sharp|C#}}==
<
class Program
Line 259:
Console.Write("Goodbye, World!");
}
}</
=={{header|C++}}==
<
int main() {
std::cout << "Goodbye, World!";
return 0;
}</
=={{header|Clipper}}==
<
=={{header|Clojure}}==
<
=={{header|COBOL}}==
<
PROGRAM-ID. GOODBYE-WORLD.
Line 284:
END-DISPLAY
.
STOP RUN.</
=={{header|CoffeeScript}}==
Node JS:
<
=={{header|Common Lisp}}==
<
=={{header|Creative Basic}}==
<syntaxhighlight lang="creative basic">
'In a window
Line 340:
'Since this a Cbasic console program.
END
</syntaxhighlight>
=={{header|D}}==
{{works with|D|2.0}}
<
void main() {
write("Goodbye, World!");
}</
=={{header|Dc}}==
<syntaxhighlight lang
<syntaxhighlight lang
=={{header|Delphi}}==
<
{$APPTYPE CONSOLE}
Line 361:
begin
Write('Goodbye, World!');
end.</
=={{header|DWScript}}==
<syntaxhighlight lang
=={{header|Dyalect}}==
<
=={{header|Dylan.NET}}==
Line 377:
{{works with|.NET|4.5}}
One Line version:
<
Goodbye World Program:
<syntaxhighlight lang="dylan.net">
//compile using the new dylan.NET v, 11.5.1.2 or later
//use mono to run the compiler
Line 396:
end class
</syntaxhighlight>
=={{header|Déjà Vu}}==
<
=={{header|EchoLisp}}==
<
(begin
(write "GoodBye, World")
(write "Next on same line"))
</syntaxhighlight>
=={{header|Elena}}==
ELENA 4.x:
<
{
//print will not append a newline
console.write("Goodbye, World!")
}</
=={{header|Elixir}}==
<
IO.write "Goodbye, World!"
</syntaxhighlight>
=={{header|Emacs Lisp}}==
<
{{out}}
Line 430:
=={{header|Erlang}}==
In erlang a newline must be specified in the format string.
<
=={{header|ERRE}}==
<syntaxhighlight lang="erre">
.......
PRINT("Goodbye, World!";)
.......
</syntaxhighlight>
=={{header|Euphoria}}==
<
puts(1,"Goodbye, world!")</
=={{header|F Sharp|F#}}==
<
// A program that will run in the interpreter (fsi.exe)
printf "Goodbye, World!";;
Line 453:
printf "Goodbye, World!"
0
</syntaxhighlight>
=={{header|Factor}}==
<
"Goodbye, World!" write</
=={{header|Falcon}}==
With the print() function:
<
Or via "fast print":
<
=={{header|Fantom}}==
<
class Main {
Void main() {
Line 473:
}
}
</syntaxhighlight>
=={{header|FOCAL}}==
FOCAL does not insert a newline unless we specifically request one.
<
=={{header|Forth}}==
<
." Goodbye, World!"</
=={{header|Fortran}}==
<
write (*,'(a)',advance='no') 'Goodbye, World!'
end program bye</
The "advance" facility was introduced with F90, as was the ability to specify format instructions (the <code>'(A)'</code> part) without a separate FORMAT statement. Earlier, there was a common extension:
<
1 FORMAT (A,$)
END</
In this, the FORMAT instruction is to accept alphabetic text (the A) from the WRITE statement, followed by the special $ item (of no mnemonic form) which signified that there was not to be any new line action at the end of the output. This sort of thing is useful when writing a prompt to the screen so that the input of the response appears on the same screen line. The text could also have been incorporated into the FORMAT statement, which would be useful if there were many WRITE statements scattered about that were to send forth the same text.
Line 499:
=={{header|FreeBASIC}}==
<
Print "Goodbye, World!"; '' the trailing semi-colon suppresses the new line
Sleep</
=={{header|Frink}}==
<
=={{header|Gambas}}==
'''[https://gambas-playground.proko.eu/?gist=09c8c3464c556325f089f9e4c326eaca Click this link to run this code]'''
<
Print "Goodbye, "; 'The semicolon stops the newline being added
Print "World!"
End</
Output:
<pre>
Line 521:
=={{header|gecho}}==
<
=={{header|Genie}}==
<
/*
Hello, with no newline, in Genie
Line 531:
init
stdout.printf("%s", "Goodbye, World!")</
{{out}}
Line 539:
=={{header|GML}}==
<
=={{header|Go}}==
<
import "fmt"
func main() { fmt.Print("Goodbye, World!") }</
=={{header|Groovy}}==
<
=={{header|GUISS}}==
In Graphical User Interface Support Script, we specify a newline, if we want one. The following will not produce a newline:
<
=={{header|Harbour}}==
<
or
QQout( "Goodbye, world" )
</syntaxhighlight>
=={{header|Haskell}}==
<
=={{header|HolyC}}==
<
=={{header|Io}}==
<syntaxhighlight lang="io">
write("Goodbye, World!")
</syntaxhighlight>
=={{header|Huginn}}==
<
exec huginn --no-argv -E "${0}" "${@}"
#! huginn
Line 582:
print( "Goodbye, World!" );
return ( 0 );
}</
=={{header|Icon}} and {{header|Unicon}}==
Native output in Icon and Unicon is performed via the ''write'' and ''writes'' procedures. The ''write'' procedure terminates each line with both a return and newline (for consistency across platforms). The ''writes'' procedure omits this. Additionally, the programming library has a series of ''printf'' procedures as well.
<
writes("Goodbye, World!")
end</
=={{header|IWBASIC}}==
<syntaxhighlight lang="iwbasic">
'In a window
Line 638:
'Since this an IWBASIC console program.
END
</syntaxhighlight>
=={{header|J}}==
On a linux system, you can use 1!:3 because stdout is a file:
<
Goodbye, World! </
However, J works in environments other than Linux, so...
'''Solution''':<code>prompt</code> from the misc package.
'''Example''':<
prompt 'Goodbye, World!'
Goodbye, World!</
'''Notes''': J programs are normally run from a REPL, or session manager, which comes in several flavors. The traditional commandline-based terminal (jconsole), one of several desktop applications (jqt for the current version of J, jgtk and jwd for older but still supported versions), a web-based frontend (jhs), and various mobile apps (J for iOS, Android).
Line 660:
=={{header|Jack}}==
<
function void main () {
do Output.printString("Goodbye, World!");und
return;
}
}</
=={{header|Janet}}==
<
=={{header|Java}}==
<
{
public static void main(String[] args)
Line 677:
System.out.print("Goodbye, World!");
}
}</
=={{header|JavaScript}}==
Node JS:
<
=={{header|jq}}==
The "-j" command-line option suppresses the newline that would otherwise be printed, e.g. if "$" is the command-line prompt:
<
Goodbye, World!$ </
The trailing "$" is the command-line prompt.
Similarly:
<
Goodbye, World!$ </
=={{header|Jsish}}==
<
Evaluated from the command line as:
Line 703:
=={{header|Julia}}==
Julia provides a <code>println</code> function which appends a newline, and a <code>print</code> function which doesn't:
<
=={{header|Kotlin}}==
{{trans|Java}}
<
=={{header|Lasso}}==
Lasso provides a <code>stdoutnl</code> method that prints a trailing newline, and a <code>stdout</code> method that does not:
<
=={{header|LFE}}==
<
(io:format "Goodbye, World")
</syntaxhighlight>
=={{header|Liberty BASIC}}==
A trailing semicolon prevents a newline
<
</syntaxhighlight>
=={{header|LIL}}==
<syntaxhighlight lang
=={{header|Limbo}}==
<
include "sys.m"; sys: Sys;
Line 740:
sys = load Sys Sys->PATH;
sys->print("Goodbye, World!"); # No automatic newline.
}</
=={{header|LLVM}}==
<
; LLVM does not provide a way to print values, so the alternative would be
; to just load the string into memory, and that would be boring.
Line 756:
%1 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @"OUTPUT_STR", i32 0, i32 0))
ret i32 0
}</
=={{header|Logtalk}}==
No action is necessary to avoid an unwanted newline.
<
:- object(error_message).
Line 768:
:- end_object.
</syntaxhighlight>
=={{header|Lua}}==
<
=={{header|m4}}==
Line 777:
(Quoted) text is issued verbatim, "dnl" suppresses all input until and including the next newline. Simply creating an input without a trailing newline would of course accomplish the same task.
<syntaxhighlight lang
=={{header|MANOOL}}==
<
=={{header|Maple}}==
<syntaxhighlight lang="maple">
printf( "Goodbye, World!" );
</syntaxhighlight>
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<
Another one that works in scripts:
<
=={{header|MATLAB}} / {{header|Octave}}==
<
=={{header|min}}==
<
=={{header|mIRC Scripting Language}}==
<syntaxhighlight lang
=={{header|ML/I}}==
===Simple solution===
In ML/I, if there isn't a newline in the input, there won't be one in the output; so a simple solution is this (although it's hard to see that there isn't a newline).
<syntaxhighlight lang
===More sophisticated solution===
To make it clearer, we can define an ML/I ''skip'' to delete itself and an immediately following newline.
<
Goodbye, World!""</
=={{header|Modula-2}}==
<
FROM Terminal IMPORT WriteString,ReadChar;
Line 817:
WriteString("Goodbye, World!");
ReadChar
END HelloWorld.</
=={{header|N/t/roff}}==
Line 825:
Because /.ROFF/ is a document formatting language, most text input is expected to be text input which will get output on paper, so there is usually no need to run a special procedure or routine to output text.
<
Goodbye, World!
</syntaxhighlight>
=={{header|Nanoquery}}==
<
=={{header|Neko}}==
The Neko builtin $print does not add a newline.
<syntaxhighlight lang="actionscript">/**
hellonnl.neko
Tectonics:
Line 848:
*/
$print("Goodbye, World!");</
{{out}}
Line 857:
=={{header|Nemerle}}==
<
module Hello
Line 867:
Write("Goodbye, ");
Write("world!");
}</
=={{header|NetRexx}}==
<
options replace format comments java crossref symbols binary
say 'Goodbye, World!\-'
</syntaxhighlight>
=={{header|NewLISP}}==
<
=={{header|Nim}}==
<
=={{header|NS-HUBASIC}}==
<
=={{header|Oberon-2}}==
<
MODULE HelloWorld;
IMPORT Out;
Line 892:
Out.String("Goodbye, world!")
END HelloWorld.
</syntaxhighlight>
=={{header|Objeck}}==
<
bundle Default {
class SayGoodbye {
Line 904:
}
}
</syntaxhighlight>
=={{header|OCaml}}==
Line 910:
In OCaml, the function <code>[http://caml.inria.fr/pub/docs/manual-ocaml/libref/Pervasives.html#VALprint_endline print_endline]</code> prints a string followed by a newline character on the standard output and flush the standard output. And the function <code>[http://caml.inria.fr/pub/docs/manual-ocaml/libref/Pervasives.html#VALprint_string print_string]</code> just prints a string with nothing additional.
<
=={{header|Oforth}}==
<
=={{header|Ol}}==
To omit the trailing newline use `display` instead of `print`.
<
(display "Goodbye, World!")
</syntaxhighlight>
=={{header|OOC}}==
To omit the trailing newline use print instead of println:
<
"Goodbye, World!" print()
}</
=={{header|Oxygene}}==
{{incorrect|Oxygene|output isn't consistent with the task's requirements: wording, capitalization.}}
<
namespace HelloWorld;
Line 951:
end.
</syntaxhighlight>
<pre>
>HelloWorld.exe
Line 958:
=={{header|Panoramic}}==
<syntaxhighlight lang="panoramic">
rem insert a trailing semicolon.
print "Goodbye, World!";
print " Nice having known you."</
=={{header|PARI/GP}}==
<
=={{header|Pascal}}==
<
begin
write('Goodbye, World!');
end.</
Output:
<pre>% ./NewLineOmission
Line 978:
=={{header|PASM}}==
<
end</
=={{header|Perl}}==
<
=={{header|Phix}}==
Phix does not add '\n' automatically, except for the '?' (debugging) shorthand; if you want one you must remember to add it explicitly.
<!--<
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Goodbye, World!"</span><span style="color: #0000FF;">)</span>
<!--</
=={{header|PHL}}==
Printf doesn't add newline automatically.
<
extern printf;
Line 999:
printf("Goodbye, World!");
return 0;
]</
=={{header|PHP}}==
<
=={{header|Picat}}==
<
=={{header|PicoLisp}}==
<
=={{header|Pict}}==
<
=={{header|Pike}}==
<
=={{header|Pixilang}}==
<
=={{header|PL/I}}==
<syntaxhighlight lang="pl/i">
put ('Goodbye, World!');
</syntaxhighlight>
=={{header|Plain English}}==
<
Start up.
Write "Goodbye, world!" on the console without advancing.
Wait for the escape key.
Shut down.</
=={{header|PowerShell}}==
<
Write-Host -NoNewLine "World!"</
{{Out}}
<pre>Goodbye, World!PS C:\></pre>
=={{header|Processing}}==
<
print("Goodbye, World!"); /* No automatic newline */
</syntaxhighlight>
=={{header|PureBasic}}==
<
Print("Goodbye, World!")
Input() ;wait for enter key to be pressed</
=={{header|Python}}==
<
sys.stdout.write("Goodbye, World!")</
{{works with|Python|3.x}}
<
=={{header|Quackery}}==
Line 1,059:
Quackery does not automatically insert a new line.
<
=={{header|R}}==
<
=={{header|Ra}}==
<syntaxhighlight lang="ra">
class HelloWorld
**Prints "Goodbye, World!" without a new line**
Line 1,072:
print "Goodbye, World!" without new line
</syntaxhighlight>
=={{header|Racket}}==
<
(display "Goodbye, World!")</
=={{header|Raku}}==
(formerly Perl 6)
A newline is not added automatically to print or printf
<syntaxhighlight lang="raku"
printf "%s", "Goodbye, World!";</
=={{header|RASEL}}==
<syntaxhighlight lang="text">"!dlroW ,olleH">:?@,Gj</
=={{header|REBOL}}==
<
=={{header|Red}}==
<
=={{header|Retro}}==
<syntaxhighlight lang
=={{header|REXX}}==
Line 1,100:
<br>blank line so as to not leave the state of the terminal with malformed "text lines" (which can be followed by other text
<br>(lines) from a calling program(s), or the operating system (shell) which is usually some sort of a "prompt" text string.
<
call charout ,'Goodbye, World!'</
=={{header|Ring}}==
<
=={{header|Ruby}}==
<
=={{header|Run BASIC}}==
<
=={{header|Rust}}==
<
print!("Goodbye, World!");
}</
=={{header|Salmon}}==
<
=={{header|Scala}}==
Line 1,125:
===Ad hoc REPL solution===
Ad hoc solution as [http://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop REPL] script. Type this in a REPL session:
<
=={{header|Scheme}}==
<
=={{header|Scilab}}==
Scilab can emulate C <code>printf</code> which, by default, does not return the carriage.
<
=={{header|Seed7}}==
<
const proc: main is func
begin
write("Goodbye, World!");
end func;</
=={{header|SETL}}==
<
=={{header|Sidef}}==
<
or:
<
=={{header|Smalltalk}}==
<
Transcript show: 'Goodbye, World!'.
</syntaxhighlight>
=={{header|Standard ML}}==
<
=={{header|Swift}}==
{{works with|Swift|2.x+}}
<
{{works with|Swift|1.x}}
<
=={{header|Tcl}}==
<
=={{header|Transact-SQL}}==
{{incorrect|Transact-SQL|output isn't consistent with the task's requirements: wrong word.}}
As an output statement, PRINT always adds a new line
<syntaxhighlight lang
or:
As a result set
<syntaxhighlight lang
=={{header|TUSCRIPT}}==
<
$$ MODE TUSCRIPT
PRINT "Goodbye, World!"
</syntaxhighlight>
Output:
<pre>
Line 1,187:
=={{header|TXR}}==
Possible using access to standard output stream via TXR Lisp:
<
Goodbye, world!$</
=={{header|UNIX Shell}}==
Line 1,195:
{{works with|Bourne Shell}}
<
printf %s "-hyphens and % signs" # Use %s with arbitrary strings.</
Unfortunately, older systems where you have to rely on vanilla Bourne shell may not have a ''printf'' command, either. It's possible that there is no command available to complete the task, but only on very old systems. For the rest, one of these two should work:
<
or
<
The ''print'' command, from the [[Korn Shell]], would work well, but most shells have no ''print'' command. (With [[pdksh]], ''print'' is slightly faster than ''printf'' because ''print'' runs a built-in command, but ''printf'' forks an external command. With [[ksh93]] and [[zsh]], ''print'' and ''printf'' are both built-in commands.)
Line 1,210:
{{works with|zsh}}
<
print -nr -- "-hyphens and \backslashes"</
==={{header|C Shell}}===
C Shell does support <code>echo -n</code> and omits the newline.
<
echo -n "-hyphens and \backslashes"</
=={{header|Ursa}}==
Ursa doesn't output a newline to an I/O device by default, so simply omitting an endl object at the end of the output stream is all that's needed.
<
=={{header|Verbexx}}==
<
=={{header|Verilog}}==
<
initial
begin
Line 1,234:
$finish ;
end
endmodule</
=={{header|Vim Script}}==
<
=={{header|Visual Basic .NET}}==
<
Sub Main()
Line 1,247:
End Sub
End Module</
=={{header|Vlang}}==
<
=={{header|Web 68}}==
Line 1,256:
Use the command 'tang -V hello.w68', then 'chmod +x hello.a68', then './hello.a68'
<
=={{header|Wren}}==
<
=={{header|XLISP}}==
Either
<
or
<
=={{header|XPath}}==
<syntaxhighlight lang
=={{header|XPL0}}==
<
Text(0, "Goodbye, World!")</
=={{header|XSLT}}==
<
=={{header|zkl}}==
<
Console.write("Goodbye, World!");</
=={{header|Zig}}==
<
pub fn main() !void {
try std.io.getStdOut().writer().writeAll("Hello world!");
}</
=={{header|ZX Spectrum Basic}}==
<
20 PRINT "Goodbye, World!";</
{{omit from|SQL PL|It does not provide a command to not add a new line. There is not CALL DBMS_OUTPUT.CURRENT_LINE, only CALL DBMS_OUTPUT.NEW_LINE}}
|