Properties of a notation for combining functions

Jean Claude Raoult, Ravi Sethi

Research output: Chapter in Book/Report/Conference proceedingConference contribution

1 Citation (Scopus)

Abstract

A notation based on pipes in the unix™ operating system is proposed for combining functions in a linear order. Examples suggest that semantic rules using pipes (i.e. the notation) are easy to read and understand, even for readers with little knowledge of semantics. The readability is a consequence of the operational intuition associated with pipes. The operational view is that each function is handed a sequence of values. Generally the sequence is treated as a stack; a function pops zero or more arguments off the stack, pushes zero or more results onto the stack, and passes the stack to the next function. The new idea is that a function may skip over some number of values before picking up its arguments. This approach is suited to expressing the composition of operations on machine states in a programming language. Pipes mesh smoothly with other metalanguage concepts, e.g., lambda abstraction. The bulk of the paper explores mathematical properties of pipes. In order for pipes to fit into lambda expressions, the arguments of the constructed function has to be well defined. Operationally speaking, we have to keep track of the elements in the stack. Pipes allow continuation semantics to be written with direct operators: instead of the operator having to worry about its continuation, the second function in a pipe is essentially a continuation of the first. A connection is established between functions connected by pipes and more traditional continuation semantics. This connection is made possible by a combinator do that constructs continuation versions of direct operators, e.g., continuation style operators from the literature for arithmetic, assigning to an identifier, and determining the value of an identifier, can be constructed from their direct counterparts using do. An example of the translation of a pipe based semantic rule for let expressions into a continuation based semantic rule is given.

Original languageEnglish (US)
Title of host publicationAutomata, Languages and Programming - 9th Colloquium
PublisherSpringer Verlag
Pages429-441
Number of pages13
Volume140 LNCS
ISBN (Print)9783540115762
DOIs
StatePublished - Jan 1 1982
Externally publishedYes
Event9th International Colloquium on Automata, Languages and Programming, ICALP 1982 - Aarhus, Denmark
Duration: Jul 12 1982Jul 16 1982

Publication series

NameLecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)
Volume140 LNCS
ISSN (Print)0302-9743
ISSN (Electronic)1611-3349

Other

Other9th International Colloquium on Automata, Languages and Programming, ICALP 1982
CountryDenmark
CityAarhus
Period7/12/827/16/82

Fingerprint

Notation
Continuation
Pipe
Semantics
Operator
Handed
Zero
State Machine
Linear Order
Operating Systems
Programming Languages
Well-defined
Computer programming languages
Mesh
Chemical analysis

ASJC Scopus subject areas

  • Theoretical Computer Science
  • Computer Science(all)

Cite this

Raoult, J. C., & Sethi, R. (1982). Properties of a notation for combining functions. In Automata, Languages and Programming - 9th Colloquium (Vol. 140 LNCS, pp. 429-441). (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics); Vol. 140 LNCS). Springer Verlag. https://doi.org/10.1007/BFb0012789

Properties of a notation for combining functions. / Raoult, Jean Claude; Sethi, Ravi.

Automata, Languages and Programming - 9th Colloquium. Vol. 140 LNCS Springer Verlag, 1982. p. 429-441 (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics); Vol. 140 LNCS).

Research output: Chapter in Book/Report/Conference proceedingConference contribution

Raoult, JC & Sethi, R 1982, Properties of a notation for combining functions. in Automata, Languages and Programming - 9th Colloquium. vol. 140 LNCS, Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics), vol. 140 LNCS, Springer Verlag, pp. 429-441, 9th International Colloquium on Automata, Languages and Programming, ICALP 1982, Aarhus, Denmark, 7/12/82. https://doi.org/10.1007/BFb0012789
Raoult JC, Sethi R. Properties of a notation for combining functions. In Automata, Languages and Programming - 9th Colloquium. Vol. 140 LNCS. Springer Verlag. 1982. p. 429-441. (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)). https://doi.org/10.1007/BFb0012789
Raoult, Jean Claude ; Sethi, Ravi. / Properties of a notation for combining functions. Automata, Languages and Programming - 9th Colloquium. Vol. 140 LNCS Springer Verlag, 1982. pp. 429-441 (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)).
@inproceedings{9852512a55d64bf89fa5fcbb1ec0bd8b,
title = "Properties of a notation for combining functions",
abstract = "A notation based on pipes in the unix™ operating system is proposed for combining functions in a linear order. Examples suggest that semantic rules using pipes (i.e. the notation) are easy to read and understand, even for readers with little knowledge of semantics. The readability is a consequence of the operational intuition associated with pipes. The operational view is that each function is handed a sequence of values. Generally the sequence is treated as a stack; a function pops zero or more arguments off the stack, pushes zero or more results onto the stack, and passes the stack to the next function. The new idea is that a function may skip over some number of values before picking up its arguments. This approach is suited to expressing the composition of operations on machine states in a programming language. Pipes mesh smoothly with other metalanguage concepts, e.g., lambda abstraction. The bulk of the paper explores mathematical properties of pipes. In order for pipes to fit into lambda expressions, the arguments of the constructed function has to be well defined. Operationally speaking, we have to keep track of the elements in the stack. Pipes allow continuation semantics to be written with direct operators: instead of the operator having to worry about its continuation, the second function in a pipe is essentially a continuation of the first. A connection is established between functions connected by pipes and more traditional continuation semantics. This connection is made possible by a combinator do that constructs continuation versions of direct operators, e.g., continuation style operators from the literature for arithmetic, assigning to an identifier, and determining the value of an identifier, can be constructed from their direct counterparts using do. An example of the translation of a pipe based semantic rule for let expressions into a continuation based semantic rule is given.",
author = "Raoult, {Jean Claude} and Ravi Sethi",
year = "1982",
month = "1",
day = "1",
doi = "10.1007/BFb0012789",
language = "English (US)",
isbn = "9783540115762",
volume = "140 LNCS",
series = "Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)",
publisher = "Springer Verlag",
pages = "429--441",
booktitle = "Automata, Languages and Programming - 9th Colloquium",
address = "Germany",

}

TY - GEN

T1 - Properties of a notation for combining functions

AU - Raoult, Jean Claude

AU - Sethi, Ravi

PY - 1982/1/1

Y1 - 1982/1/1

N2 - A notation based on pipes in the unix™ operating system is proposed for combining functions in a linear order. Examples suggest that semantic rules using pipes (i.e. the notation) are easy to read and understand, even for readers with little knowledge of semantics. The readability is a consequence of the operational intuition associated with pipes. The operational view is that each function is handed a sequence of values. Generally the sequence is treated as a stack; a function pops zero or more arguments off the stack, pushes zero or more results onto the stack, and passes the stack to the next function. The new idea is that a function may skip over some number of values before picking up its arguments. This approach is suited to expressing the composition of operations on machine states in a programming language. Pipes mesh smoothly with other metalanguage concepts, e.g., lambda abstraction. The bulk of the paper explores mathematical properties of pipes. In order for pipes to fit into lambda expressions, the arguments of the constructed function has to be well defined. Operationally speaking, we have to keep track of the elements in the stack. Pipes allow continuation semantics to be written with direct operators: instead of the operator having to worry about its continuation, the second function in a pipe is essentially a continuation of the first. A connection is established between functions connected by pipes and more traditional continuation semantics. This connection is made possible by a combinator do that constructs continuation versions of direct operators, e.g., continuation style operators from the literature for arithmetic, assigning to an identifier, and determining the value of an identifier, can be constructed from their direct counterparts using do. An example of the translation of a pipe based semantic rule for let expressions into a continuation based semantic rule is given.

AB - A notation based on pipes in the unix™ operating system is proposed for combining functions in a linear order. Examples suggest that semantic rules using pipes (i.e. the notation) are easy to read and understand, even for readers with little knowledge of semantics. The readability is a consequence of the operational intuition associated with pipes. The operational view is that each function is handed a sequence of values. Generally the sequence is treated as a stack; a function pops zero or more arguments off the stack, pushes zero or more results onto the stack, and passes the stack to the next function. The new idea is that a function may skip over some number of values before picking up its arguments. This approach is suited to expressing the composition of operations on machine states in a programming language. Pipes mesh smoothly with other metalanguage concepts, e.g., lambda abstraction. The bulk of the paper explores mathematical properties of pipes. In order for pipes to fit into lambda expressions, the arguments of the constructed function has to be well defined. Operationally speaking, we have to keep track of the elements in the stack. Pipes allow continuation semantics to be written with direct operators: instead of the operator having to worry about its continuation, the second function in a pipe is essentially a continuation of the first. A connection is established between functions connected by pipes and more traditional continuation semantics. This connection is made possible by a combinator do that constructs continuation versions of direct operators, e.g., continuation style operators from the literature for arithmetic, assigning to an identifier, and determining the value of an identifier, can be constructed from their direct counterparts using do. An example of the translation of a pipe based semantic rule for let expressions into a continuation based semantic rule is given.

UR - http://www.scopus.com/inward/record.url?scp=84976827982&partnerID=8YFLogxK

UR - http://www.scopus.com/inward/citedby.url?scp=84976827982&partnerID=8YFLogxK

U2 - 10.1007/BFb0012789

DO - 10.1007/BFb0012789

M3 - Conference contribution

AN - SCOPUS:84976827982

SN - 9783540115762

VL - 140 LNCS

T3 - Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)

SP - 429

EP - 441

BT - Automata, Languages and Programming - 9th Colloquium

PB - Springer Verlag

ER -