# Simple cat program

One of the most common standard tasks (especially when showcasing esoteric programming languages) is to implement a "cat program": read all of STDIN and print it to STDOUT. While this is named after the Unix shell utility cat it is of course much less powerful than the real thing, which is normally used to print (and concatenate) several files read from disc.

You should write a full program which reads the contents of the standard input stream and writes them verbatim to the standard output stream. If and only if your language does not support standard input and/or output streams (as understood in most languages), you may instead take these terms to mean their closest equivalent in your language (e.g. JavaScript's prompt and alert). These are the only admissible forms of I/O, as any other interface would largely change the nature of the task and make answers much less comparable.

The output should contain exactly the input and nothing else. The only exception to this rule is constant output of your language's interpreter that cannot be suppressed, such as a greeting, ANSI color codes or indentation. This also applies to trailing newlines. If the input does not contain a trailing newline, the output shouldn't include one either! (The only exception being if your language absolutely always prints a trailing newline after execution.)

Output to the standard error stream is ignored, so long as the standard output stream contains the expected output. In particular, this means your program can terminate with an error upon hitting the end of the stream (EOF), provided that doesn't pollute the standard output stream. If you do this, I encourage you to add an error-free version to your answer as well (for reference).

As this is intended as a challenge within each language and not between languages, there are a few language specific rules:

• If it is at all possible in your language to distinguish null bytes in the standard input stream from the EOF, your program must support null bytes like any other bytes (that is, they have to be written to the standard output stream as well).
• If it is at all possible in your language to support an arbitrary infinite input stream (i.e. if you can start printing bytes to the output before you hit EOF in the input), your program has to work correctly in this case. As an example yes | tr -d \\n | ./my_cat should print an infinite stream of ys. It is up to you how often you print and flush the standard output stream, but it must be guaranteed to happen after a finite amount of time, regardless of the stream (this means, in particular, that you cannot wait for a specific character like a linefeed before printing).

• This is not about finding the language with the shortest solution for this (there are some where the empty program does the trick) - this is about finding the shortest solution in every language. Therefore, no answer will be marked as accepted.

• Submissions in most languages will be scored in bytes in an appropriate preexisting encoding, usually (but not necessarily) UTF-8.

Some languages, like Folders, are a bit tricky to score. If in doubt, please ask on Meta.

• Feel free to use a language (or language version) even if it's newer than this challenge. Languages specifically written to submit a 0-byte answer to this challenge are fair game but not particularly interesting.

Note that there must be an interpreter so the submission can be tested. It is allowed (and even encouraged) to write this interpreter yourself for a previously unimplemented language.

Also note that languages do have to fulfil our usual criteria for programming languages.

• If your language of choice is a trivial variant of another (potentially more popular) language which already has an answer (think BASIC or SQL dialects, Unix shells or trivial Brainfuck derivatives like Headsecks or Unary), consider adding a note to the existing answer that the same or a very similar solution is also the shortest in the other language.

• Unless they have been overruled earlier, all standard rules apply, including the http://meta.codegolf.stackexchange.com/q/1061.

As a side note, please don't downvote boring (but valid) answers in languages where there is not much to golf; these are still useful to this question as it tries to compile a catalogue as complete as possible. However, do primarily upvote answers in languages where the author actually had to put effort into golfing the code.

### Catalogue

The Stack Snippet at the bottom of this post generates the catalogue from the answers a) as a list of shortest solution per language and b) as an overall leaderboard.

## Language Name, N bytes


where N is the size of your submission. If you improve your score, you can keep old scores in the headline, by striking them through. For instance:

## Ruby, <s>104</s> <s>101</s> 96 bytes


If there you want to include multiple numbers in your header (e.g. because your score is the sum of two files or you want to list interpreter flag penalties separately), make sure that the actual score is the last number in the header:

## Perl, 43 + 2 (-p flag) = 45 bytes


You can also make the language name a link which will then show up in the snippet:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes


<style>body { text-align: left !important} #answer-list { padding: 10px; width: 290px; float: left; } #language-list { padding: 10px; width: 290px; float: left; } table thead { font-weight: bold; } table td { padding: 5px; }</style><script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="language-list"> <h2>Shortest Solution by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr> </thead> <tbody id="languages"> </tbody> </table> </div> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr> </thead> <tbody id="answers"> </tbody> </table> </div> <table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table><script>var QUESTION_ID = 62230; var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe"; var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk"; var OVERRIDE_USER = 8478; var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page; function answersUrl(index) { return "//api.stackexchange.com/2.2/questions/" + QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER; } function commentUrl(index, answers) { return "//api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER; } function getAnswers() { jQuery.ajax({ url: answersUrl(answer_page++), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { answers.push.apply(answers, data.items); answers_hash = []; answer_ids = []; data.items.forEach(function(a) { a.comments = []; var id = +a.share_link.match(/\d+/); answer_ids.push(id); answers_hash[id] = a; }); if (!data.has_more) more_answers = false; comment_page = 1; getComments(); } }); } function getComments() { jQuery.ajax({ url: commentUrl(comment_page++, answer_ids), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { data.items.forEach(function(c) { if (c.owner.user_id === OVERRIDE_USER) answers_hash[c.post_id].comments.push(c); }); if (data.has_more) getComments(); else if (more_answers) getAnswers(); else process(); } }); } getAnswers(); var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/; var OVERRIDE_REG = /^Override\s*header:\s*/i; function getAuthorName(a) { return a.owner.display_name; } function process() { var valid = []; answers.forEach(function(a) { var body = a.body; a.comments.forEach(function(c) { if(OVERRIDE_REG.test(c.body)) body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>'; }); var match = body.match(SCORE_REG); if (match) valid.push({ user: getAuthorName(a), size: +match[2], language: match[1], link: a.share_link, }); else console.log(body); }); valid.sort(function (a, b) { var aB = a.size, bB = b.size; return aB - bB }); var languages = {}; var place = 1; var lastSize = null; var lastPlace = 1; valid.forEach(function (a) { if (a.size != lastSize) lastPlace = place; lastSize = a.size; ++place; var answer = jQuery("#answer-template").html(); answer = answer.replace("{{PLACE}}", lastPlace + ".") .replace("{{NAME}}", a.user) .replace("{{LANGUAGE}}", a.language) .replace("{{SIZE}}", a.size) .replace("{{LINK}}", a.link); answer = jQuery(answer); jQuery("#answers").append(answer); var lang = a.language; lang = jQuery('<a>'+lang+'</a>').text(); languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang.toLowerCase(42), user: a.user, size: a.size, link: a.link}; }); var langs = []; for (var lang in languages) if (languages.hasOwnProperty(lang)) langs.push(languages[lang]); langs.sort(function (a, b) { if (a.lang_raw > b.lang_raw) return 1; if (a.lang_raw < b.lang_raw) return -1; return 0; }); for (var i = 0; i < langs.length; ++i) { var language = jQuery("#language-template").html(); var lang = langs[i]; language = language.replace("{{LANGUAGE}}", lang.lang) .replace("{{NAME}}", lang.user) .replace("{{SIZE}}", lang.size) .replace("{{LINK}}", lang.link); language = jQuery(language); jQuery("#languages").append(language); } }</script>

• Bash, 3 bytes: cat Oct 31 '15 at 19:02
• @TheDoctor I guess this would fall into the "don't use a builtin which does exactly what is needed" rule. Oct 31 '15 at 19:46
• @PaŭloEbermann There is no such rule, and the corresponding standard loophole is no longer accepted. (In fact, there is already a sh answer using cat which also contains a shorter solution using dd.) Oct 31 '15 at 20:25
• If only it used standard methods of input and output: ///, 0 bytes. Mar 31 '17 at 19:33
• @SparklePony Except, you'd have to escape slashes and backslashes. Mar 31 '17 at 20:35

# Fishing, Dock length 2, 9 bytes

v+CC
IP


I takes an input and P prints it. Note that N can be substituted for P to produce a trailing newline.

• You might want to note that Fishing is not capable of a) preserving linefeeds, b) determining EOF, c) reading arbitrary infinite streams, because it always reads lines (waiting for a linefeed character)... at least as far as the reference interpreter goes. Also I don't think it's fair to count this by the dock length. The byte count of this code is 9 bytes. Nov 13 '15 at 7:06

## Go, 66 bytes

package main
import("io"
."os")
func main(){io.Copy(Stdout,Stdin)}


Go has an io.Copy function which writes what reads; until EOF.

## ResPlicate, 36 bytes

4 2 0 -1 4 2 4 2 4 2 4 2 4 2 1 0 0 0


This was one of the earliest examples I made after implementing this language, so I have simply copied it from the linked wiki article, which I largely wrote. As was mentioned there, this program does not halt on EOF, and will continue asking for input until the interpreter is killed by force.

### ResPlicate in a nutshell

Programs in ResPlicate are all comprised of a list of integers, which are inserted into a queue in order. Each step, the first two integers are popped as x and y. Then a list of x integers is popped (and padded with zeros if the queue had fewer than x elements) and re-enqueued y times. This is quite sufficient to ensure Turing-completeness. Indeed, it is even Turing-complete in the limited case that y is not allowed to exceed 2.

This simple language is extended with I/O in the following way: If x is zero and y is positive, y is output as a character. If x is zero and y is negative, a character is read from input, y+1 is added to it, and the result is enqueued.

### Ungolfed

4 2 [0 -1 4 2]                  Enqueue 0 -1 (read one character) followed by this command.
4 2 [4 2 4 2]                   Enqueue 4 2 followed by this command.
4 2 [1 0 0 0]                   Put two copies of 1 0 0 0 on the cue.
This sequence and the one preceding it can be considered
together to be a single command which appends
1 0 0 0 to itself.


After these commands, the queue looks like this:

0 -1 4 2 0 -1 4 2 4 2 4 2 4 2 4 2 1 0 0 0 1 0 0 0


In other words, the program has decompressed itself into a copy of itself with 0 -1 prepended and 1 0 0 0 appended, and since the program will eventually (and forever) return to this state, this could be considered the "real" cat program. The execution continues like so:

0 -1                            Get a character from stdin, append it to the queue.
4 2 [0 -1 4 2]
4 2 [4 2 4 2]
4 2 [1 0 0 0]                   As above.
1 0 [0]                         Pop and discard the zero.
0 (x)                           Print the inputted character x.


After which the program is once again in the state I said it would return to.

## Aubergine, 9 bytes

=ii=oo=ib


### Aubergine in a nutshell

Aubergine has four variables and four 2-argument instructions. The variables a and b can be indirected as A and B to point to locations in the program, which can be read and written just like data, making it inherently self-modifying. The other variables are o, which refers to input or output depending on whether it is the second or first argument of the assignment instruction, and i, which is the instruction pointer. The four instructions are assignment (=), addition (+), subtraction (-), and conditional jump (:). The only constant literal available is 1. All variables are initialized to zero.

### Ungolfed:

=ii                      NOP placeholder, since instruction pointer moves after jumps
=oo                      Read a character from stdin, print it to stdout.
=ib                      Send the instruction pointer to value of b, which is 0 by default


This version runs forever and must be killed manually. To make it so that it exits upon receiving a null byte, we must add 3 bytes:

=ii=ao=oa:ba


# Chaîne, 2 bytes

Because strings.

|i
|  ; perform next character as instruction
i ; takes input to the stack
; implicit: output stack


## ROOP, 5 bytes

I
W
O


Never ends.

# WhoScript, 39 bytes

1pr;v;#0 1;-;i;>;e;<;t=;ti;o;tl;pw;pr;d


I think its best explained by watching the stack change over time.

psychic_paper read          @ [input]
time_vortex                 @ [input]
# 0 1                     @ [input, 0, 1]
-                         @ [input, -1.0]
integer                   @ [input, -1]
pop                       @ [input]
duplicate                 @ [input, input]
push                      @ [input, input, -1]
TARDIS =                  @ [input, input==-1]
TARDIS if                 @ [input]
opening                 @ [-1] (it won't come this far otherwise)
TARDIS landing            @ [input | -1]
psychic_paper write       @ []


The program will accept any input so long as you don't find a character whose ASCII code is -1. The program works best if input is provided from the command line, else it will just take one character at a time until you quit providing new ones.

## AnnieFlow, 2 bytes

11


The first 1 indicates that the program accepts input, and the second 1 indicates that there is one stack. The output stack has no changeable behavior, so that's the only information the program needs. Because the output stack is always the first stack and the input stack is always the last stack, they coincide in this case, so when the input stack is filled, it outputs the same to STDOUT instead of storing it. In any program, after the input stack is filled it is popped to start the program. However, popping from the output stack halts the program. Therefore the program halts immediately after outputting the input. This was not an intended feature, it just happened to work out the way it does because of how the programming language works.

# Y, 4 bytes

i:gF


Simple enough. This two-link program takes input characters and prints them out as you feed input. Input an empty string to terminate. Explanation:

i:g F
i      take input (string)
:     duplicate
g    print one item
F  conditional link: pop N, and if N is zero (falsey), i.e. empty string, continue.
otherwise, move to beginning of current link


# SPARC (V9) assembly, 64 bytes

This runs on NetBSD (I seem to be running version 6.1.5). Disassembly with objdump:

0000000000100078 <.text>:
100078:   9c 23 a0 08     sub  %sp, 8, %sp
10007c:   82 10 20 03     mov  3, %g1
100080:   90 10 00 00     mov  %g0, %o0
100084:   92 10 00 0e     mov  %sp, %o1
100088:   94 10 20 01     mov  1, %o2
10008c:   91 d0 20 00     ta  0
100090:   02 ca 00 07     brz  %o0, 0x1000ac
100094:   82 10 20 04     mov  4, %g1
100098:   90 10 20 01     mov  1, %o0
10009c:   92 10 00 0e     mov  %sp, %o1
1000a0:   94 10 20 01     mov  1, %o2
1000a4:   10 bf ff f6     b  0x10007c
1000a8:   91 d0 20 00     ta  0
1000ac:   9c 03 a0 08     add  %sp, 8, %sp
1000b0:   82 10 20 01     mov  1, %g1
1000b4:   91 d0 20 00     ta  0


## Explanation (line-by-line):

First of all, the SPARC architecture has a ton of registers. You have access to 32 of them at a time, called %gX, %iX, %lX, and %oX for X in [0..7]. There are also %pc for the program counter and %sp for the stack pointer.

sub %sp, 8, %sp


The stack grows downward. I didn't want to include a .data section, so I'm using the stack as storage. This expands it by 8 bytes.

mov 3, %g1
mov %g0, %o0
mov %sp, %o1
mov 1, %o2


Getting ready to do a syscall. The ABI in use here requires the syscall number in %g1 and the arguments in %o0, %o1, etc. According to syscall.h, read is 3. Register %g0 is always 0, so these lines equate to read(0, sp, 1).

ta 0


Those familiar with x86 assembly might want int 0x80 to do the syscall. In SPARC, we use a user-mode trap, and in NetBSD specifically it is the first one. Thus, ta 0.

brz %o0, 0x1000ac


A conditional branch: jump to address 0x1000ac if %o0 contains zero. We sometimes have to be careful with instruction order though, because every time the program encounters a branch, the next instruction is executed as well. In this case it doesn't make a difference, but it will later.

mov 4, %g1
mov 1, %o0
mov %sp, %o1
mov 1, %o2


Just like with read before, except we're using write (4) and stdout (1).

b 0x10007c
ta 0


An unconditional branch. Remember that thing about branches being weird? This executes the ta 0 to call the write we just prepared, then jumps back to address 0x10007c (to prepare to read again).

add %sp, 8, %sp


The target of the first branch we saw, here we prepare to exit. Start by putting the stack pointer back where it was.

mov 1, %g1
ta 0


We know that %o0 contains zero, since that was the condition of the branch that got us here. We want to exit with that status, so we simply call exit (1).

## Source:

.global _start
.section .text
_start:
sub %sp,8,%sp
1:
mov 3,%g1
mov %g0,%o0
mov %sp,%o1
mov 1,%o2
t 0
brz %o0,2f
mov 4,%g1
mov 1,%o0
mov %sp,%o1
mov 1,%o2
b 1b
t 0
2:
mov 1,%g1
t 0


# Reng v.1.2, 4 bytes

is~o


This takes input, skips if not a negative one (i.e. no input found). When s find a regular character, it skips over the ~ and outputs the input with o. Otherwise, it meets the ~ and ends execution. Input is like "string1" "string2" ... "stringN". Try it here!

The following 13-byte program allows you to feed input more than once, but only yields correct output provided you feed it in at the right time.

>isvo
/>is!


Input "Meow":

# Jelly, 1 byte

¹


Simply the identity function.

## Lua, 30 Bytes

Heavily base upon Lynn's answer, but as it is not updated anymore, I'll feel free ot post this 30 bytes answer.

::a::io.write(io.read())goto a


# Fuzzy Octo Guacamole, 3 bytes

(non-competing, FOG is newer than the challenge)

(^)


Looks emotish (that's totally a word).

The ^ gets input, the X pops it and prints it.

The ( and ) denote the start and end of an infinite loop.

4 byte solution with a for loop:

?[?^]


The [ and ] denote a for loop, and the ? increments the counter, so it never runs out.

Weird implicit outputs means it prints the outputs automatically.

• Cool!!!!!!!!!!! Mar 18 '16 at 22:28
• This is the infinite cat challenge. If it is at all possible in your language to support an arbitrary infinite input stream (i.e. if you can start printing bytes to the output before you hit EOF in the input), your program has to work correctly in this case. Mar 19 '16 at 4:57

## Javascript (browser), 16 15 bytes

alert(prompt())

• I like the rules abuse here... :-) By the way, you can save a byte by dropping the semicolon - JavaScript has automatic semicolon insertion, with only a few exceptions. Also, you probably should specify state this is for browsers only, since Node.js doesn't have either of these, but it does support console IO. May 20 '16 at 1:50
• Done! Thanks for the edit btw May 20 '16 at 1:52
• Welcome! <filler to make SE happy> May 20 '16 at 1:53

## Archway, 7 bytes

/.\
\,/


According to Esolangs, this is the only useful program that can be written in the original Archway language.

## Archway 2, 19 bytes

   \
// .
, /
+/\


# APL, 6 bytes

⎕←⍞
→1


This has worked in all APLs since the beginning of time.

⍞ wait for input
⎕← Output that
→1 go to line 1

## Wat, 6 + 1 = 7 bytes

åó#ÐÑÅ


(This code don't have any rapport with DNA)

Explanation:

åó#ÐÑÅ

ó     Duplicate the top of the stack
#    Skip the next character
Ð   End the program
Ñ  If the top of the stack is 0, go backward (execute Ð and end the program), otherwise go forward
Å Print the character on the top of the stack
After, the IP wrap and the line is reexecuted

• Wat Oct 6 '16 at 17:22

# Omam, 137 bytes

the screams all sound the same
though the truth may vary
don't listen to a word i say
the screams all sound the same
this ship will carry

Note that I haven't copied it. In fact, I added this code there today.

• Well, this is a beautiful language. Jun 29 '16 at 1:06
• @dorukayhan It's in fact BF, but with different commands. Note that this, technically, is 5 lines, i.e. 5 commands. BF golfing tips apply. Jun 29 '16 at 7:45

# Tellurium, 2 bytes

i^


Pretty simple, eh?

What it does is get input from the user using the i command, and stores it in the tape in the currently selected item (in the code above, it's 0, the default).

After that, it prints the currently selected item's value using the ^ command. (whatever the user input).

# Apps Script + Google Sheets, 29 bytes

### Script

function Q(s){return s}


### Sheet

=q(B1)


Cell B1 is the input.

• By convention A1 is the input cell for cell-based languages, and you should be able to reduce =q(b1) to =q(A1 where Google Sheets will autoformat in the terminating ) Sep 5 '17 at 16:09

# J, 14 bytes

stdout]stdin''


Reads the entire input from stdin until EOF is reached and store it as an array of characters. Then output all of it to stdout. This will work when saved as a script to be run using jconsole, where scripts are programs for interpreted languages.

# Fith, 7 bytes

read \.


read gets input from STDIN. The language cannot handle infinite streams. \. prints the string on top of the stack without a trailing newline.

• Can't do read\.? Jun 29 '16 at 13:28
• @EʀɪᴋᴛʜᴇGᴏʟғᴇʀ No. Fith's identifier rules are very lax, so read\. would be counted as a single token. Jun 29 '16 at 16:18
• And why can't you do read . then? Jun 29 '16 at 16:24
• @EʀɪᴋᴛʜᴇGᴏʟғᴇʀ That adds a newline at the end of the string. My understanding was that that shouldn't happen. Jun 29 '16 at 16:27
• Oh, okay then.. Jun 29 '16 at 16:28

## BruhScript, 22 bytes

Source:

↺₀1Λ₀⍈+⍰'
∇


Encoded version hexdump:

0000000: 0099 009a 003a 0087 009a 008f 0051 008e  .....:.......Q..
0000010: 0061 0000 0069                           .a...i


Explanation:

↺                While loop. Take two niladic functions as arguments.
₀1Λ             A function that always return 1
₀⍈+⍰'<LF>∇   '<c> is a shorthand for «<c>», so this code print (⍈) the input (⍰) + a newline ('<LF>), and return None (∇)


# Clojure, 18 bytes

(print(read-line))


This 30-bytes program runs forever:

(while true(print(read-line)))

• Wouldn't this only read and print a single line? I'm pretty sure Clojure would be able to deal with arbitrary finite and even infinite streams instead. Jun 4 '16 at 20:52
• Wouldn't this only read and print a single line? 24 days later, I worked around it. Jun 29 '16 at 1:11
• @dorukayhan It ((while true) still (prints a (read-line)))! You need to support infinite input without newlines if you can. Jun 29 '16 at 16:26
• @EʀɪᴋᴛʜᴇGᴏʟғᴇʀ Well, considering Clojure is Java in disguise, (read-line) uses System.in, which can theoretically take infinitely many bytes. Jun 29 '16 at 16:30
• Badly overdue disclaimer: This might be the first Clojure program I wrote Jun 29 '16 at 16:59

# C++ (109 Bytes)

Thanks to Eʀɪᴋ ᴛʜᴇ Gᴏʟғᴇʀ for reducing 4 bytes.

#include <iostream>
#include <string>
using namespace std;main(){string A,W;while(cin>>A)W+=A;cout<<W<<endl;}

• Can't you remove it though? Also, if I'm correct, char*A is -2 string A. That way then, I think, you can remove #include <string>\n for -18, and use #include<iostream> for -1. Also, since you will use std:: 2-3 times, you can remove using namespace std;, and replace cin, cout (and possibly endl?) with std::cin, std::cout and possible std::endl. Jun 29 '16 at 13:26

# Racket, 52 bytes

A classical approach.

(copy-port(current-input-port)(current-output-port))


In Racket, default settings are stored in parameters which are invoked to obtain their value (or invoked with an argument to set them). This mechanism is also used to access/set the default input and output ports.

# Python 3, 21 bytes

print(input(),end='')

• This doesn't support multiple lines nor an infinite stream
– Blue
Sep 27 '16 at 18:17
• Also, why not use print(end=input())? :P Dec 30 '16 at 10:57

## Pyke, 2 bytes

zr


Try it here!

z  - read_line()
r - if no error: goto_start()