routine lines

Documentation for routine lines assembled from the following types:

class Cool

From Cool

(Cool) routine lines

Defined as:

sub lines(Str(Cool))
method lines()

Coerces the invocant (and in sub form, the argument) to Str, decomposes it into lines (with the newline characters stripped), and returns the list of lines.

say lines("a\nb\n").join('|');          # OUTPUT: «a|b␤» 
say "some\nmore\nlines".lines.elems;    # OUTPUT: «3␤»

This method can be used as part of an IO::Path to process a file line-by-line, since IO::Path objects inherit from Cool, e.g.:

for 'huge-csv'.IO.lines -> $line {
    # Do something with $line 
# or if you'll be processing later 
my @lines = 'huge-csv'.IO.lines;

Without any arguments, sub lines operates on $*ARGFILES, which defaults to $*IN in the absence of any filenames.

To modify values in place use is copy to force a writable container.

for $*IN.lines -> $_ is copy { s/(\w+)/{$0 ~ $0}/.say }

class Supply

From Supply

(Supply) method lines

method lines(Supply:D: :$chomp = True --> Supply:D)

Creates a supply that will emit the characters coming in line by line from a supply that's usually created by some asynchronous I/O operation. The optional :chomp parameter indicates whether to remove line separators: the default is True.

class Str

From Str

(Str) routine lines

Defined as:

multi method lines(Str:D: $limit)
multi method lines(Str:D:)

Returns a list of lines (without trailing newline characters), i.e. the same as a call to $input.comb( / ^^ \N* /, $limit ) would.


say lines("a\nb").perl;    # OUTPUT: «("a", "b").Seq␤» 
say lines("a\nb").elems;   # OUTPUT: «2␤» 
say "a\nb".lines.elems;    # OUTPUT: «2␤» 
say "a\n".lines.elems;     # OUTPUT: «1␤»

You can limit the number of lines returned by setting the $limit variable to a non-zero, non-Infinity value:

say <not there yet>.join("\n").lines2 ); # OUTPUT: «(not there)␤»

DEPRECATED as of 6.d language, the :count argument was used to return the total number of lines:

say <not there yet>.join("\n").lines:count ); # OUTPUT: «3␤»

Use elems call on the returned Seq instead:

say <not there yet>.join("\n").lines.elems# OUTPUT: «3␤»

class IO::CatHandle

From IO::CatHandle

(IO::CatHandle) method lines

Defined as:

method lines(IO::CatHandle:D: $limit = Inf:$close --> Seq:D)

Same as IO::Handle.lines. Note that a boundary between source handles is considered to be a newline break.

(my $f1 = 'foo'.IO).spurt: "foo\nbar";
(my $f2 = 'bar'.IO).spurt: 'meow';$f1$f2).lines.perl.say;
# OUTPUT: «("foo", "bar", "meow").Seq␤» 

Note: if :$close is False, fully-consumed handles are still going to be closed.

class IO::Path

From IO::Path

(IO::Path) method lines

Defined as:

method lines(IO::Path:D: :$chomp = True:$enc = 'utf8':$nl-in = ["\x0A""\r\n"], |c --> Seq:D)

Opens the invocant and returns its lines.

The behavior is equivalent to opening the file specified by the invocant, forwarding the :$chomp, :$enc, and :$nl-in arguments to, then calling IO::Handle.lines on that handle, forwarding any of the remaining arguments to that method, and returning the resultant Seq.

NOTE: the lines are ready lazily and the handle used under the hood won't get closed until the returned Seq is fully reified, so ensure it is, or you'll be leaking open filehandles. (TIP: use the $limit argument)

say "The file contains ",
  '50GB-file'.IO.lines.grep(*.contains: 'Perl').elems,
  " lines that mention Perl";
# OUTPUT: «The file contains 72 lines that mention Perl␤» 

class IO::Handle

From IO::Handle

(IO::Handle) routine lines

Defined as:

sub lines(IO::Handle:D $fh = $*ARGFILES$limit = Inf:$close --> Seq:D)
method lines(IO::Handle:D:               $limit = Inf:$close --> Seq:D)

Return a Seq each element of which is a line from the handle (that is chunks delineated by .nl-in). If the handle's .chomp attribute is set to True, then characters specified by .nl-in will be stripped from each line.

Reads up to $limit lines, where $limit can be a non-negative Int, Inf, or Whatever (which is interpreted to mean Inf). If :$close is set to True, will close the handle when the file ends or $limit is reached. Subroutine form defaults to $*ARGFILES, if no handle is provided.

Attempting to call this method when the handle is in binary mode will result in X::IO::BinaryMode exception being thrown.

NOTE: the lines are read lazily, so ensure the returned Seq is either fully reified or is no longer needed when you close the handle or attempt to use any other method that changes the file position.

say "The file contains ",
  '50GB-file'*.contains: 'Perl').elems,
  " lines that mention Perl";
# OUTPUT: «The file contains 72 lines that mention Perl␤» 

class IO::Socket::INET

From IO::Socket::INET

(IO::Socket::INET) method lines

method lines()

Returns a lazy list of lines read from the socket.