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;"

=={{header|ALGOL 68}}==

See [[User defined pipe and redirection operators/ALGOL 68]]

'''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$;

 

# Finally check the result: #

'''Output:'''

<pre>

Pioneer: Adriaan van Wijngaarden - Dutch pioneer; ARRA, ALGOL

</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|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|Racket}}==

 

#lang racket

 

 

(require 'sample)

 

=={{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]