User defined pipe and redirection operators: Difference between revisions

* define the procedures: input(cmd,stream), pipe(stream,cmd), output(stream, stream), whereis(array), append(stream)

'''Sample shell script:''' ''¢ draft - pending a better (more interesting) suggestion ¢''

(

head -4 < List_of_computer_scientists.lst;

) | sort | uniq | tee the_important_scientists.lst | grep aa

);

'''Input Records:'''

{|class="wikitable" style="text-align: center; margin: 1em auto 1em auto;"

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of Currying.}}

'''File: Iterator_pipe_operators.a68'''

PAGEIN = PAGE,

PAGEAPPEND = REF PAGE,

>> = (GENLINE gen, PAGEAPPEND page)VOID: gen(APPEND page),

=: = (GENLINE gen, FILTER filter)GENLINE: filter(gen),

'''File: Iterator_pipe_utilities.a68'''

* c.f. [[User defined pipe and redirection operators/ALGOL 68#Iterator pipe utilities]]

PROC cat = ([]GENLINE argv)GENLINE:~;

PROC tee = ([]YIELDLINE args filter)FILTER:~;

PROC sort = (GENLINE arg)GENLINE:~;

PROC head = (INT n, []GENLINE args)GENLINE:~;

'''File: Iterator_pipe_page.a68'''

* c.f. [[User defined pipe and redirection operators/ALGOL 68#Iterator pipe page]]

OP READ = (PAGEIN page)GENLINE:~;

OP WRITE = (PAGEOUT page)YIELDLINE: ~;

'''File: test_Iterator_pipe_page.a68'''

# First define what kind of record (aka LINE) we are piping and filtering #

FORMAT line fmt = $xg$;

"Number of scientists: ", whole( UPB the scientists list, 0 ), newline

))

'''Output:'''

<pre>

=={{header|Go}}==

import (

fmt.Println(name, "not found")

}

Output:

<pre>

Step 0: get the data. The task does not specify how to get the data, so here I use lynx, which is readily available on most unix-like systems, including cygwin. Note that lynx needs to be in the OS PATH when running j.

Step 1: define task core algorithms:

Step 2: select and display the required data:

* Adriaan van Wijngaarden - Dutch pioneer; ARRA, ALGOL

As for the concept of a pipe that presents data one record at a time to a downstream function, that corresponds to the J operator <code>@</code> and we could achieve the "left to right" syntax mechanism by explicitly ordering its arguments <code>2 :'v@u'</code> but it's not clear how to demonstrate that usefully, in this task. (And, I could write a lot of code, to accomplish what's being accomplished here with the two successive greps, but I find that concept distasteful and tedious.)

However, note also that J's sort (<code>/:~</code>) and uniq (<code>~.</code>) operations would work just fine on this kind of data. For example:

* Adriaan van Wijngaarden - Dutch pioneer; ARRA, ALGOL

* Adriaan van Wijngaarden - Dutch pioneer; ARRA, ALGOL

;'aa' grep ~. 'ALGOL' grep data,data

* Adriaan van Wijngaarden - Dutch pioneer; ARRA, ALGOL

That said, this implements most (perhaps all) of the required complexities:

tee=: 4 :0

if._1=nc boxopen x do.(x)=: '' end.

)

This produces the result:

=={{header|Julia}}==

Uses Julia's Channels as asynchronous pipes. Note that the $( .. ) Unix command, which gathers stdin output into a single variable, is not used. Instead, a common output channel for various tasks is used to gather output. Sort() rather than sort() is used so as not to overload Base.sort().

Wil van der Aalst business process management, process mining, Petri nets

Hal Abelson intersection of computing and teaching

Sort(commonoutchan) |> uniq() |> tee("the_important_scientists.lst") |>

grep("aa") |> print_lines()

<pre>

Adriaan van Wijngaarden Dutch pioneer; ARRA, ALGOL

=={{header|Perl}}==

Implementing only stream chaining, cat, grep and tee. Oddly enough, I don't feel the urge to implement all of the more-or-less-the-same features asked for by the task.

use 5.10.0;

;

=={{header|Phix}}==

The distributed version also has a couple of alternatives for pipe_head() and pipe_tail(), along with a

class-less version that is compatible with pwa/p2js.

<span style="color: #000080;font-style:italic;">-- demo\rosetta\Fake_Redirection.exw</span>

<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- class (see other version in distro)</span>

<span style="color: #0000FF;">{}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">wait_key</span><span style="color: #0000FF;">()</span>

<span style="color: #7060A8;">abort</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">)</span>

{{out}}

<pre>

=={{header|Racket}}==

#lang racket

(require 'sample)

=={{header|Raku}}==

This assumes that the data is in a tab separated file "List_of_computer_scientists.lst" in the current directory.

sub head ($count, @positional) { @positional.head($count) }

sub redirect ($fname) { cat($fname) }

).flat .sort .unique tee 'the_important_scientists.lst') .grep: /'aa'/;

{{out}}

<pre>Pioneer: Adriaan van Wijngaarden Dutch pioneer; ARRA, ALGOL</pre>

=={{header|Tcl}}==

The syntax of redirections is slightly out, as they're inserted as explicit pipeline elements, and standard Tcl syntax is used to pull in results from sub-pipelines (because it is vastly simpler):

# Helpers

}

close $f

Sample pipeline:

set aa [pipeline \

<< [pipeline < $file | head 4] [pipeline < $file | grep ALGOL | tee "ALGOL_pioneers.txt"] [pipeline < $file | tail 4] \

| sort | uniq | tee "the_important_scientists.lst" | grep aa]

=={{header|Wren}}==

{{libheader|Wren-seq}}

Although Wren supports operator overloading, there are a number of restrictions which would make simulating the Unix shell operators awkward or even imposible. As in the Phix (and Go) examples, I've therefore used named methods instead.

var FS = {} // fake file system

System.write("Pioneer: %(FS["aa"])")

showCount.call("Number of ALGOL pioneers", "ALGOL_pioneers.lst")

{{out}}