[A6885]

A68 Assembler Reference Manual, 1985.

[AAF+98]

E. Albert, M. Alpuente, M. Falaschi, P. Julián, and G. Vidal. Improving control in functional logic program specialization. In Proc. of SAS'98. Springer LNCS 1503, 1998.

[AAFV98]

E. Albert, M. Alpuente, M. Falaschi, and G. Vidal. Indy user's manual. Technical report dsic-ii/12/98, Univ. Valencia, 1998.

[AAHV99]

E. Albert, M. Alpuente, M. Hanus, and G. Vidal. A partial evaluation framework for curry programs. In Proc.\ of the 6th International Conference on Logic for Programming and Automated Reasoning (LPAR'99), pages 376-395. Springer LNCS 1705, 1999.

[AB87]

B. Arbab and D.M. Berry. Operational and denotational semantics of prolog. Journal of Logic Programming (4), pages 309-329, 1987.

[AB90]

K.R. Apt and M. Bezem. Acyclic programs (extended abstract). In Proc. Seventh International Conference on Logic Programming, pages 617-623. MIT Press, 1990.

[AB91]

A. Aggoun and N. Beldiceanu. Overview of the chip compiler system. In Proc. International Conference on Logic Programming, pages 775-789. MIT Press, 1991.

[AB94]

K.R. Apt and R. Bol. Logic programming and negation: A survey. Journal of Logic Programming, 19&20, 1994.

[Abi92]

S. Abiteboul. Deductive and object-oriented databases. Tutorial notes for JICSLP'92, 1992.

[ABL86]

R. Amadio, K.B. Bruce, and G. Longo. The finitary projection model for second order lambda calculus and solutions to higher order domain equations. In Proc. LICS'86, pages 122-130, 1986.

[ABPS98]

K.R. Apt, J. Brunekreef, V. Partington, and A. Schaerf. Alma-0: An imperative language that supports declarative programming. ACM Transactions on Programming Languages and Systems (to appear), 1998.

[Abr84a]

H. Abramson. Definite clause translation grammars. In Proc. IEEE Internat. Symposium on Logic Programming, pages 233-240, Atlantic City, 1984.

[Abr84b]

H. Abramson. Definite clause translation grammars and the logical specification of data types as unambiguous context free grammars. Technical report 84-11, Univ. of British Columbia, Vancouver, 1984.

[Abr85]

S. Abramsky. Strictness analysis and polymorphic invariance. In Programs as Data Objects, pages 1-23. Springer LNCS 217, 1985.

[Abr92]

S. Abramsky. Tutorial on linear logic. Tutorial notes presented at LICS'92, 1992.

[AC90]

I. Attali and J. Chazarain. Functional evaluation of natural semantics specifications. Rapports de recherche no. 1218, INRIA, 1990.

[AC93]

R.M. Amadio and L. Cardelli. Subtyping recursive types. ACM Transactions on Programming Languages and Systems, 15(4):575-631, 1993.

[ACFZ90]

L. Albert, R. Casas, F. Fages, and P. Zimmermann. Average case analysis of unification algorithms. Rr 1213, INRIA, 1990.

[ACHS88]

K. Appleby, M. Carlsson, S. Haridi, and D. Sahlin. Garbage collection for prolog based on wam. Communications of the ACM, 31(6):719-741, 1988.

[ADSM85]

P. Asirelli, M. De Santis, and M. Martelli. Integrity constraints in logic databases. Journal of Logic Programming, 3:221-232, 1985.

[AE93]

K.R. Apt and S. Etalle. On the unification free prolog programs. In Proc. of the Conference on Mathematical Foundations of Computer Science (MFCS'93). Springer LNCS, 1993.

[AEH93]

S. Antoy, R. Echahed, and M. Hanus. A needed narrowing strategy. Technical report mpi-i-93-243, Max-Planck-Institut f{ür Informatik, Saarbr{ücken, 1993.

[AEH94]

S. Antoy, R. Echahed, and M. Hanus. A needed narrowing strategy. In Proc. 21st ACM Symposium on Principles of Programming Languages, pages 268-279, Portland, 1994.

[AEH96]

S. Antoy, R. Echahed, and M. Hanus. A parallel narrowing strategy. Technical report tr 96-1, Portland State University, 1996.

[AEH97]

S. Antoy, R. Echahed, and M. Hanus. Parallel evaluation strategies for functional logic languages. In Proc.\ of the Fourteenth International Conference on Logic Programming (ICLP'97), pages 138-152. MIT Press, 1997.

[AEH00]

S. Antoy, R. Echahed, and M. Hanus. A needed narrowing strategy. Journal of the ACM, 47(4):776-822, 2000. Previous version in Proc.\ 21st ACM Symposium on Principles of Programming Languages, pp.\ 268-279, 1994.

[AEL99]

M. Alpuente, S. Escobar, and S. Lucas. Upv-Curry: an Incremental Curry Interpreter. In Proc. of 26th Seminar on Current Trends in Theory and Practice of Informatics (SOFSEM'99). Springer LNCS (to appear), 1999.

[AFJV96]

M. Alpuente, M. Falaschi, P. Julian, and G. Vidal. Call-by-name partial evaluation of functional logic programs. Internal report (updated version in pepm'97), Univ. Valencia, 1996.

[AFJV97]

M. Alpuente, M. Falaschi, P. Julián, and G. Vidal. Specialization of lazy functional logic programs. Proc. of the ACM SIGPLAN Symposium on Partial Evaluation and Semantics-Based Program Manipulation (PEPM'97), SIGPLAN Notices, 32(12):151-162, 1997.

[AFM92]

M. Alpuente, M. Falaschi, and F. Manzo. Analyses of inconsistency for incremental equational logic programming. In Proc. of the 4th International Symposium on Programming Language Implementation and Logic Programming, pages 443-457. Springer LNCS 631, 1992.

[AFM96]

S. Abdennadher, T. Frühwirth, and H. Meuss. On confluence of constraint handling rules. In Proc. 2nd International Conference on Principles and Practice of Constraint Programming (CP'96). Springer LNCS 1118, 1996.

[AFM97a]

S. Abdennadher, T. Frühwirth, and H. Meuss. Confluence and semantics of constraint simplification rules. Technical report, submitted to constraint journal, LMU M{ünchen, 1997.

[AFM97b]

O. Agesen, S.N. Freund, and J.C. Mitchell. Adding type parameterization to the java language. In Proc. OOPSLA'97, pages 49-65. ACM SIGPLAN Notices Vol. 32 No. 10, 1997.

[AFRV93]

M. Alpuente, M. Falaschi, M.J. Ramis, and G. Vidal. Narrowing approximations as an optimization for equational logic programs. In Proc. of the 5th International Symposium on Programming Language Implementation and Logic Programming, pages 391-409. Springer LNCS 714, 1993.

[AFV96]

M. Alpuente, M. Falaschi, and G. Vidal. Narrowing-driven partial evaluation of functional logic programs. In Proc. 6th European Symposium on Programming (ESOP'96), pages 45-61. Springer LNCS 1058, 1996.

[AFV98a]

M. Alpuente, M. Falaschi, and G. Vidal. Experiments with the call-by-value partial evaluator. Technical report dsic-ii/13/98, Univ. Valencia, 1998.

[AFV98b]

M. Alpuente, M. Falaschi, and G. Vidal. Partial evaluation of functional logic programs. ACM Transactions on Programming Languages and Systems, 20(4):768-844, 1998.

[AG94]

S. Antoy and J. Gannon. Using term rewriting to verify software. IEEE Transactions on Software Engineering, 20(4):259-274, 1994.

[Aga96]

B. Agapiev. An equational presentation of logic programming. Technical report, Oregon Graduate Insitute of Science and Technology, Beaverton, 1996.

[Agh90]

G. Agha. Concurrent object-oriented programming. Communications of the ACM, 33(9):125-141, 1990.

[AH87a]

S. Abramsky and C. Hankin, editors. Abstract Interpretation of Declarative Languages. Ellis Horwood, 1987.

[AH87b]

S. Abramsky and C. Hankin. An introduction to abstract interpretation. In S. Abramsky and C. Hankin, editors, Abstract Interpretation of Declarative Languages, pages 9-31. Ellis Horwood, 1987.

[AH91]

S. Antoy and D. Hamlet. Objects that check themselves against formal specifications. Portland State University, 1991.

[AH92a]

S. Antoy and D. Hamlet. Automatically checking an implementation against its formal specification. Technical report tr 91-1, rev. 1, Portland State University, 1992.

[AH92b]

S. Antoy and D. Hamlet. Self-checking against formal specifications. In Proc. Fourth International Conference on Computing and Information, pages 355-360, 1992.

[AH00]

S. Antoy and M. Hanus. Compiling multi-paradigm declarative programs into prolog. In Proc. International Workshop on Frontiers of Combining Systems (FroCoS'2000), pages 171-185. Springer LNCS 1794, 2000.

[AHLV99]

M. Alpuente, M. Hanus, S. Lucas, and G. Vidal. Specialization of inductively sequential functional logic programs. In Proc. of the International Conference on Functional Programming (ICFP'99), pages 273-283. ACM Press, 1999.

[AHMS01]

S. Antoy, M. Hanus, B. Massey, and F. Steiner. An implementation of narrowing strategies. In Proc.\ of the 3rd International ACM SIGPLAN Conference on Principles and Practice of Declarative Programming (PPDP 2001). ACM Press (to appear), 2001.

[AHV00]

E. Albert, M. Hanus, and G. Vidal. Using an abstract representation to specialize functional logic programs. In Proc.\ of the 7th International Conference on Logic for Programming and Automated Reasoning (LPAR 2000), pages 381-398. Springer LNCS 1955, 2000.

[AHV01]

E. Albert, M. Hanus, and G. Vidal. A practical partial evaluator for a multi-paradigm declarative language. In Proc.\ of the 5th International Symposium on Functional and Logic Programming (FLOPS 2001), pages 326-342. Springer LNCS 2024, 2001.

[Aik94]

A. Aiken. Set constraints: Results, applications and future directions. In Principles and Practice of Constraint Programming, pages 326-335. Springer LNCS 874, 1994.

[AIM88]

P. Asirelli, P. Inverardi, and A. Mustaro. Improving integrity constraint checking in deductive databases. In 2nd International Conference on Database Theory, pages 72-86. Springer LNCS 326, 1988.

[AK90a]

H. A\"\it-Kaci. An overview of life. In J.W. Schmidt and A.A. Stogny, editors, Proc. Workshop on Next Generation Information System Technology, pages 42-58. Springer LNCS 504, 1990.

[AK90b]

H. A\"\it-Kaci. The wam: A (real) tutorial. Research report 5, DEC Paris Research Laboratory, 1990.

[AK91]

H. A\"\it-Kaci. Warren's Abstract Machine. MIT Press, 1991.

[AK93]

H. A\"\it-Kaci. Programming with life. Slides of a tutorial presented at ILPS'93, 1993.

[AKG92]

H. A\"\it-Kaci and J. Garrique. Label-selective $λ$-calculus. DEC Paris Research Laboratory, 1992.

[AKL88]

H. A\"\it-Kaci and P. Lincoln. Life: A natural language for natural language. Technical report number aca-st-074-88, MCC, 1988.

[AKLN87]

H. A\"\it-Kaci, P. Lincoln, and R. Nasr. Le fun: Logic, equations, and functions. In Proc. 4th IEEE Internat. Symposium on Logic Programming, pages 17-23, San Francisco, 1987.

[AKN86]

H. A\"\it-Kaci and R. Nasr. Login: A logic programming language with built-in inheritance. Journal of Logic Programming (3), pages 185-215, 1986.

[AKP91]

H. A\"\it-Kaci and A. Podelski. Towards a meaning of life. In Proc. of the 3rd Int. Symposium on Programming Language Implementation and Logic Programming, pages 255-274. Springer LNCS 528, 1991.

[AKP92]

H. A\"\it-Kaci and A. Podelski. Logic programming with order-sorted features and functions. DEC Paris Research Laboratory, 1992.

[AKP94]

H. A\"\it-Kaci and A. Podelski. Functions as passive constraints in life. ACM Transactions on Programming Languages and Systems, 16(4):1279-1318, 1994.

[AKPG92]

H. A\"\it-Kaci, A. Podelski, and S.C. Goldstein. Order-sorted feature theory unification. DEC Paris Research Laboratory, 1992.

[AKPS92]

H. A\"\it-Kaci, A. Podelski, and G. Smolka. A feature-based constraint system for logic programming with entailment. In Proc. Fifth Generation Computer Systems 1992, pages 1012-1021, 1992.

[Ala88]

B. Alabiso. Transformation of data flow analysis models to object oriented design. In Proc. OOPSLA'88, pages 335-353. SIGPLAN Notices 23(11), 1988.

[ALS94]

J. Avenhaus and C. Lor\'\ia-Sáenz. On conditional rewrite systems with extra variables and deterministic logic programs. In Proc. LPAR'94, pages 215-229. Springer LNAI 822, 1994.

[ALSS95]

J. Avenhaus, C. Lor\'\ia-Sáenz, and J. Steinbach. A reduction ordering for hihger-order terms. Seki-report sr-95-03, Univ. Kaiserslautern, 1995.

[AM87]

M. Abadi and Z. Manna. Temporal logic programming. In Proc. 4th IEEE Internat. Symposium on Logic Programming, pages 4-16, San Francisco, 1987.

[AM89]

A. Asperti and S. Martini. Projections instead of variables: A category theoretic interpretation of logic programs. In Proc. Sixth International Conference on Logic Programming (Lisboa), pages 337-352. MIT Press, 1989.

[AM90]

J. Avenhaus and K. Madlener. Term rewriting and equational reasoning. In R.B. Banerji, editor, Formal Techniques in Artificial Intelligence, pages 1-43. Elsevier Science Publishers, 1990.

[AM94]

S. Antoy and A. Middeldorp. A sequential reduction strategy. In 4th International Conference on Algrabraic and Logic Programming, pages 168-185. Springer LNCS 850, 1994.

[AM96]

S. Antoy and A. Middeldorp. A sequential reduction strategy. Theoretical Computer Science, 165:75-95, 1996.

[AMSS94]

T. Armstrong, K. Marriott, P. Schachte, and H. Søndergaard. Boolean functions for dependency analysis: Algebraic properties and efficient representation. In Proc. 1st International Static Analysis Symposium, pages 266-280. Springer LNCS 864, 1994.

[ANP81]

T. Allen, R. Nix, and A. Perlis. Pen: A hierarchical document editor. In Proc. ACM SIGPLAN SIGOA Symposium on Text Manipulation, Portland/Oregon, pages 74-81. SIGOA Newsletter, Vol. 2, No. 1+2, 1981.

[Ant91a]

S. Antoy. Lazy evaluation in logic. In Proc. of the 3rd Int. Symposium on Programming Language Implementation and Logic Programming, pages 371-382. Springer LNCS 528, 1991.

[Ant91b]

S. Antoy. Non-determinism and lazy evaluation in logic programming. In Proc. Int. Workshop on Logic Program Synthesis and Transformation (LOPSTR'91), pages 318-331. Springer Workshops in Computing, 1991.

[Ant92a]

S. Antoy. Definitional trees. In Proc. of the 3rd International Conference on Algebraic and Logic Programming, pages 143-157. Springer LNCS 632, 1992.

[Ant92b]

S. Antoy. Lazy rewriting in logic programming. Technical report tr 90-17, rev. 2, Portland State University, 1992.

[Ant92c]

S. Antoy. Normalization by leftmost innermost rewriting. In Proc. of the 3rd Intern. Workshop on Conditional Term Rewriting Systems, pages 448-457. Springer LNCS 656, 1992.

[Ant92d]

S. Antoy. Normalization by leftmost innermost rewriting. Technical report tr-92-3, Portland State University, 1992.

[Ant96]

S. Antoy. Needed narrowing in prolog. Technical report 96-2, Portland State University, 1996.

[Ant97a]

S. Antoy. Optimal non-deterministic functional logic computations. In Proc. International Conference on Algebraic and Logic Programming (ALP'97), pages 16-30. Springer LNCS 1298, 1997.

[Ant97b]

S. Antoy. Optimal non-deterministic functional logic computations. Technical report, Portland State University, 1997.

[AP90]

K.R. Apt and D. Pedreschi. Studies in pure prolog: Termination. Report cs-r9048, CWI Amsterdam, 1990.

[AP91a]

H. A\"\it-Kaci and A. Podelski. Functions as passive constraints in life. Research report 13, DEC Paris Research Laboratory, 1991.

[AP91b]

H. A\"\it-Kaci and A. Podelski. Towards a meaning of life. Research report 11, DEC Paris Research Laboratory, 1991.

[AP93]

K.R. Apt and D. Pedreschi. Modular termination proofs for logic and pure prolog programs. In Proc. of the Fourth Int. School for Computer Science Researchers. Oxford University Press, 1993.

[AP94]

K.R. Apt and A. Pellegrini. On the occur-check-free prolog programs. ACM Transactions on Programming Languages and Systems, 16(3):687-726, 1994.

[APS88]

A. Aasa, K. Petersson, and D. Synek. Concrete syntax for data objects in functional languages. In Proc. Lisp and Functional Programming Conference, 1988.

[Apt88]

K.R. Apt. Introduction to logic programming. Report cs-r8826, CWI Amsterdam, 1988.

[Apt98]

K.R. Apt. Programming in alma-0, or imperative and declarative programming reconciled. In Proc. Frontiers of Combining Systems'98 (FroCoS'98). Kluwer, 1998.

[AR97]

L. Araujo and J.J. Ruz. A parallel prolog system for distributed memory. Journal of Logic Programming, 33(1):49-79, 1997.

[AR98]

S. Anantharaman and G. Richard. A rewrite mechanism for logic programs with negation. Theoretical Computer Science 192, pages 77-106, 1998.

[Ari89]

Aristide. A logic of semi-functions, inclusions and equality: The setting. Report crin 89-r-058, CRIN, Nancy, 1989.

[Arm97]

J. Armstrong. The development of erlang. In Proc. of the International Conference on Functional Programming (ICFP'97), pages 196-203. ACM SIGPLAN Notices Vol. 32, No. 8, 1997.

[AS97]

K.R. Apt and A. Schaerf. Search and imperative programming. In Proc.\ of the 24th ACM Symposium on Principles of Programming Languages (Paris), pages 67-79, 1997.

[ASGLLF94a]

P. Arenas-Sánchez, A. Gil-Luezas, and F.J. López-Fraguas. Combining lazy narrowing with disequality constraints. In Proc. of the 6th International Symposium on Programming Language Implementation and Logic Programming, pages 385-399. Springer LNCS 844, 1994.

[ASGLLF94b]

P. Arenas-Sánchez, A. Gil-Luezas, and P. López-Fraguas. Combining lazy narrowing with disequality constraints. Technical report dia 94/2, Universidad Complutense Madrid, 1994.

[ASHGLFUH96]

P. Arenas-Sánchez, T. Hortalá-González, F.J. López-Fraguas, and E. Ullán-Hernández. Functional logic programming with real numbers. In Proc. JICSLP'96 Workshop on Multi-Paradigm Logic Programming, pages 47-57. TU Berlin, Technical Report No. 96-28, 1996.

[ASLFRA98]

P. Arenas-Sánchez, F.J. López-Fraguas, and M. Rodr\'\iguez-Artalejo. Embedding multiset constraints into a lazy functional logic language. In Principles of Declarative Programming (Proc. Joint International Symposium PLILP/ALP'98), pages 429-444. Springer LNCS 1490, 1998.

[ASLFRA99]

P. Arenas-Sánchez, F.J. López-Fraguas, and M. Rodr\'\iguez-Artalejo. Functional plus logic programming with built-in and symbolic constraints. In Proc.\ of the International Conference on Principles and Practice of Declarative Programming (PPDP'99), pages 152-169. Springer LNCS 1702, 1999.

[ASRA97]

P. Arenas-Sánchez and M. Rodr\'\iguez-Artalejo. A semantic framework for functional logic programming with algebraic polymorphic types. In Proc. CAAP'97. Springer LNCS, 1997.

[ASS+88]

A. Aiba, K. Sakai, Y. Sato, D.J. Hawley, and R. Hasegawa. Constraint logic programming language cal. In Proc. Int. Conf. on Fifth Generation Computer Systems, pages 263-276, 1988.

[A{\ss}m95]

U. A\ssmann. On edge addition rewrite systems and their relevance to program analysis. Technical report, INRIA Rocquencourt, 1995.

[ASU85]

A.V. Aho, R. Sethi, and J.D. Ullman. Compilers: Principles, Techniques and Tools. Addison-Wesley, Reading, Mass., 1985.

[AT99]

S. Antoy and A. Tolmach. Typed higher-order narrowing without higher-order strategies. In Proc. 4th Fuji International Symposium on Functional and Logic Programming (FLOPS'99), pages 335-352. Springer LNCS 1722, 1999.

[Aus90]

D. Austry. The vtp project: Modular abstract syntax specification. Rapports de recherche no. 1219, INRIA, 1990.

[AV89]

G. Aguzzi and M.C. Verri. On the termination of a unification procedure. In Proc. of the Third Italian Conference on Theoretical Computer Science, pages 59-70, 1989.

[AvE82]

K.R. Apt and M.H. van Emden. Contributions to the theory of logic programming. Journal of the ACM, 29(3):841-862, 1982.

[AVW92]

J.L. Armstrong, S.R. Virding, and M.C. Williams. Use of prolog for developing a new programming language. In Practical Applications of Prolog, London, 1992. Institute of Electrical Engineers.

[AWWV96]

J. Armstrong, M. Williams, C. Wikstrom, and R. Virding. Concurrent Programming in Erlang. Prentice Hall, 1996.

[Bac78]

J. Backus. Can programming be liberated from the von neumann style? a functional style and its algebra of programs. Comm. of the ACM, 21(8):613-641, 1978.

[Bac88a]

L. Bachmair. Proof by consistency in equational theories. In Proc. LICS'88, 1988.

[Bac88b]

L. Bachmair. Proof methods for equational theories. SUNY at Stony Brook, 1988.

[Bac88c]

R.C. Backhouse. Constructive type theory - an introduction. In Constructive Methods in Computing Science (International Summer School), pages 9-60. Springer, 1988.

[Bai89]

S.C. Bailin. An object-oriented requirements specification method. Communications of the ACM, 32(5):608-623, 1989.

[Ban86]

R.G. Bandes. Constraining-unification and the programming language unicorn. In D. DeGroot and G. Lindstrom, editors, Logic Programming, Functions, Relations, and Equations, pages 397-410. Prentice Hall, 1986.

[Bar81]

H.P. Barendregt. The Lambda Calculus. North-Holland, Amsterdam, 1981.

[Bar87]

J. Barklund. Efficient interpretation of prolog programs. In SIGPLAN'87 Symposium on Interpreters and Interpretiv Technqiues, pages 132-137. ACM SIGPLAN Notices Vol. 22, No. 7, 1987.

[Bau88]

M. Baudinet. Proving termination properties of prolog programs: A semantic approach. In Proc. Logic in Computer Science, pages 336-347, 1988.

[Bau89]

H. Baumeister. Implementierung und datenabstraktion in extended ml. Univ. Dortmund, 1989.

[BB87]

K. H. Bl{äsius and H.-J. B{ürckert, editors. Deduktionssysteme - Automatisierung des logischen Denkens. Oldenbourg, M{ünchen, 1987.

[BB89]

S. Böttcher and C. Beierle. Database support for the protos-l system. Iwbs report 71, IBM Deutschland, 1989.

[BB91]

C. Beierle and E. Börger. A wam extension for type-constraint logic programming: Specification and correctness proof. Iwbs report 200, IBM Germany, 1991.

[BB92]

D. Boulanger and M. Bruynooghe. Deriving fold/unfolgd transformation of logic programs using extended oldt-based abstract interpretation. Technical report cw 163, K.U. Leuven, 1992.

[BB93]

M. Bruynooghe and D. Boulanger. Abstract interpretation for (constraint) logic programming. Report cw 183, K.U. Leuven, 1993. To appear in: Constraint Programming (B. Mayoh, E. Tougu, J. Penjam, eds.), Springer, 1994.

[BBB+91]

M. Baur, A. Bockmayr, C. Brzoska, E. Heinz, P. Lukowicz, H.H. Rath, C. Scharnhorst, and B. Schiele. Benutzeranleitung für die ka-prolog sprachfamilie. Internal report 20/91, Univ. Karlsruhe, 1991.

[BBCT86]

K.A. Bowen, K.A. Buettner, I. Cicekli, and A.K. Turk. The design and implementation of a high-speed incremental portable prolog compiler. In Proc. Third International Conference on Logic Programming (London), pages 650-656. Springer LNCS 225, 1986.

[BBG+87]

M. Bellia, P.G. Bosco, E. Giovannetti, G. Levi, C. Moiso, and C. Palamidessi. A two-level approach to logic and functional programming. In Proc. PARLE'87, 1987.

[BBH91]

R. Barnett, D. Basin, and J. Hesketh. A recursion planning analysis of inductive completion. Dai research paper no. 518, Univ. of Edinburgh, 1991.

[BBL+91]

A. Bockmayr, C. Brzoska, N. Lindenberg, B. Neidecker, H.H. Rath, C. Scharnhorst, B. Schiele, and I. Varsek. Ka-prolog: Sprachdefinition. Internal report 19/91, Univ. Karlsruhe, 1991.

[BBLM84]

R. Barbuti, M. Bellia, G. Levi, and M. Martelli. On the integration of logic programming and functional programming. In Proc. IEEE Internat. Symposium on Logic Programming, pages 160-166, Atlantic City, 1984.

[BBLM86]

R. Barbuti, M. Bellia, G. Levi, and M. Martelli. Leaf: a language which integrates logic, equations and functions. In D. DeGroot and G. Lindstrom, editors, Logic Programming, Functions, Relations, and Equations, pages 201-238. Prentice Hall, 1986.

[BBM91]

C. Beierle, S. Böttcher, and G. Meyer. Draft report of the logic programming language protos-l. Iwbs report 175, IBM Deutschland, 1991.

[BBN+91]

F. Baader, H.-J. Bürckert, B. Nebel, W. Nutt, and G. Smolka. On the expressivity of feature logics with negation, functional uncertainty, and sort equations. Research report rr-91-01, DFKI, 1991.

[BC89a]

K. Beck and W. Cunningham. A laboratory for teaching object-oriented thinking. In Proc. OOPSLA'89, pages 1-6. SIGPLAN Notices 24(10), 1989.

[BC89b]

A. Brogi and P. Ciancarini. Shared prolog. Univ. Pisa, 1989.

[BC93a]

M. Bruynooghe and M. Codish. Freeness, sharing, linearity and correctness - all at once. In Proc. Third International Workshop on Static Analysis, pages 153-164. Springer LNCS 724, 1993.

[BC93b]

M. Bruynooghe and M. Codish. Freeness, sharing, linearity and correctness - all at once. Report cw 179, K.U. Leuven, 1993. Also in Proc. WSA'93, Springer LNCS 724.

[BCG+89]

P.G. Bosco, C. Cecci, E. Giovannetti, C. Moiso, and C. Palamidessi. Using resolution for a sound and efficient integration of logic and functional programming. In J. deBakker, editor, Languages for parallel architectures. Wiley (UK), 1989.

[BCGL92]

R. Barbuti, M. Codish, R. Giacobazzi, and G. Levi. Modelling prolog control. In Proc. 19th Symposium on Principles of Programming Languages, pages 95-104, 1992.

[BCHP96]

F. Bueno, D. Cabeza, M. Hermenegildo, and G. Puebla. Global analysis of standard prolog programs. In Proc. 6th European Symposium on Programming (ESOP'96), pages 108-124. Springer LNCS 1058, 1996.

[BCM88]

P.G. Bosco, C. Cecchi, and C. Moiso. Exploiting the full power of logic plus functional programming. In Proc. 5th Conference on Logic Programming & 5th Symposium on Logic Programming (Seattle), pages 3-17, 1988.

[BCM89]

P.G. Bosco, C. Cecchi, and C. Moiso. An extension of wam for k-leaf: a wam-based compilation of conditional narrowing. In Proc. Sixth International Conference on Logic Programming (Lisboa), pages 318-333. MIT Press, 1989.

[BCM+90]

P.G. Bosco, C. Cecchi, C. Moiso, M. Porta, and G. Sofi. Logic and functional programming on distributed memory architectures. In Proc. Seventh International Conference on Logic Programming, pages 325-339. MIT Press, 1990.

[BD93]

R. Bol and L. Degerstedt. The underlying search for magic templates and tabulation. Report lith-ida-93-01, Link{öping University, 1993.

[BD97]

P.A. Bigot and S.K. Debray. A simple approach to suuporting untagged objects in dynamically typed languages. Journal of Logic Programming, 32(1):25-47, 1997.

[BDM88]

F. Bry, H. Decker, and R. Manthey. A unifor, approach to constraint satisfaction and constraint satisfiability in deductive databases. In Int. Conf. on Extending Database Technology, pages 488-505. Springer LNCS 303, 1988.

[BDSK86]

M. Bruynooghe, D. De Schreye, and B. Krekels. Compiling control. In Proc. IEEE Internat. Symposium on Logic Programming, pages 70-77, Salt Lake City, 1986.

[BDSK89]

M. Bruynooghe, D. De Schreye, and B. Krekels. Compiling control. Journal of Logic Programming (6), pages 135-162, 1989.

[BE86]

D. Bert and R. Echahed. Design and implementation of a generic, logic and functional programming language. In Proc. European Symposium on Programming, pages 119-132. Springer LNCS 213, 1986.

[BE88]

M. Brayshaw and M. Eisenstadt. Adding data and procedure abstraction to the transparent prolog machine (tpm). In Proc. 5th Conference on Logic Programming & 5th Symposium on Logic Programming (Seattle), pages 532-547. MIT Press, 1988.

[BE91]

M. Brayshaw and M. Eisenstadt. A practical graphical tracer for prolog. Int. Journal of Man-Machine Studies, 35:597-631, 1991.

[BE95]

D. Bert and R. Echahed. Abstraction of conditional term rewriting systems. In Proc. of the 1995 International Logic Programming Symposium, pages 147-161. MIT Press, 1995.

[Bee88]

J. Beer. The occur-check problem revisited. Journal of Logic Programming, 5:243-261, 1988.

[Bei89]

C. Beierle. Types, modules and databases in the logic programming language protos-l. In Sorts and Types in Artificial Intelligence. Springer LNCS 418, 1989.

[Bei92]

C. Beierle. Logic programming with typed unification and its realization on an abstract machine. IBM Journal of Research and Development, 36(3):375-390, 1992.

[Bei95]

C. Beierle. Type inferencing for polymorphic order-sorted logic programs. In Proc. International Conference on Logic Programming, pages 765-779. MIT Press, 1995.

[Bel88]

M. Bellia. Logic and functional programming by retractions. Theoretical Informatics and Applications, 22(3):271-310, 1988.

[Ben00]

B.W. Benson. Servlets - web-based applications you can live with. ACM SIGPLAN Notices, 35(3):21-24, 2000.

[BE{ø}93]

D. Bert, R. Echahed, and M. østvold. Abstract rewriting. In Proc. Third International Workshop on Static Analysis, pages 178-192. Springer LNCS 724, 1993.

[Ber86]

K. Berkling. Headorder reduction: A graph reduction scheme for the operational lambda calculus. Case report no. 8613, Syracuse University, 1986.

[Ber90]

H. Bertling. Knuth-bendix completion of horn clause programs for restricted linear resolution and paramodulation. In Proc. CTRS'90, 1990.

[BER93]

D. Bert, R. Echahed, and J.-C. Reynaud. Reference manual of the specification language lpg. Technical report, LGI-IMAG, Gernoble, 1993.

[Bes89]

P. Besnard. On infinite loops in logic programming. Report rr 1096, INRIA, 1989.

[BFG+91]

M. Broy, C. Facci, R. Grosu, R. Hettler, H. Hussmann, D. Nazareth, F. Regensburger, and K. Stolen. The requirement and design specification language spectrum: An informal introduction version 0.3. Report tum-i9140, TU M{ünchen, 1991.

[BFGT88]

A. Brogi, R. Filippi, M. Gaspari, and F. Turini. An expert system for data fusion based on a blackboard architecture. Univ. Pisa, 1988.

[BFHW94]

C. Böschen, C. Fecht, A.V. Hense, and R. Wilhelm. An abstract machine for an object-oriented language with top-level classes. Technical report a 02/94, Universit{ät des Saarlandes, 1994.

[BFR90]

A. Bondorf, F. Frauendorf, and M. Richter. An experiment in automatic self-applicable partial evaluation of prolog. Report 335, Univ. Dortmund, 1990.

[BG85]

H. Bertling and H. Ganzinger. A structure editor based on term rewriting. Univ. Dortmund, 1985.

[BG86]

P.G. Bosco and E. Giovannetti. Ideal: An ideal deductive applicative language. In Proc. IEEE Internat. Symposium on Logic Programming, pages 89-94, Salt Lake City, 1986.

[BG89a]

R. Barbuti and R. Giacobazzi. A bottom-up polymorphic type inference in logic programming. Technical report 27/89, Dip. di Informatica, Università di Pisa, 1989.

[BG89b]

H. Bertling and H. Ganzinger. Completion-time optimization of rewrite-time goal solving. In Proc. of the Conference on Rewriting Techniques and Applications, pages 45-58. Springer LNCS 355, 1989.

[BG89c]

A. Brogi and R. Gorrieri. A distributed, net oriented semantics for delta prolog. In Proc. TAPSOFT'89, pages 162-177. Springer LNCS 351, 1989.

[BG90a]

L. Bachmair and H. Ganzinger. Completion of first-order clauses with equality by strict superposition. In Proc. 2nd Int. Workshop on Conditional and Typed Rewriting, pages 162-180. Springer LNCS 516, 1990.

[BG90b]

L. Bachmair and H. Ganzinger. On restrictions of ordered paramodulation with simplification. In Proc. 10th Int. Conf. on Automated Deduction, pages 427-441. Springer LNCS 449, 1990.

[BG91a]

L. Bachmair and H. Ganzinger. Perfect model semantics for logic programs with equality. In Proc. International Conference on Logic Programming, pages 645-659. MIT Press, 1991.

[BG91b]

L. Bachmair and H. Ganzinger. Rewrite-based equational theorem proving with selection and simplification. Report 208, MPI Informatik, Saarbr{ücken, 1991.

[BG93]

A. Brogi and R. Gorrieri. Distributed logic programming. Journal of Logic Programming, 15(4):295-336, 1993.

[BG96]

A. Brogi and C. Guarino. Pruning the search space of logic programs. In Proc. 5th International Workshop on Extensions of Logic Programming, pages 35-49. Springer LNAI 1050, 1996.

[BGL+87]

P.G. Bosco, E. Giovannetti, G. Levi, C. Moiso, and C. Palamidessi. A complete semantic characterization of k-leaf, a logic language with partial functions. In Proc. 4th IEEE Internat. Symposium on Logic Programming, pages 318-327, San Francisco, 1987.

[BGL93]

R. Barbuti, R. Giacobazzi, and G. Levi. A general framework for semantics-based bottom-up abstract interpretation of logic programs. ACM TOPLAS, 15(1):133-181, 1993.

[BGLM94]

A. Bossi, M. Gabbrielli, G. Levi, and M. Martelli. The s-semantics approach: Theory and applications. Journal of Logic Programming, 19&20, 1994.

[BGM87]

P.G. Bosco, E. Giovannetti, and C. Moiso. Refined strategies for semantic unification. In Proc. of the TAPSOFT '87, pages 276-290. Springer LNCS 250, 1987.

[BGM88]

P.G. Bosco, E. Giovannetti, and C. Moiso. Narrowing vs. sld-resolution. Theoretical Computer Science 59, pages 3-23, 1988.

[BGOT95]

B. Bütow, R. Giegerich, E. Ohlebusch, and S. Thesing. A new strategy for semantic matching. In Proc. of PLILP'95. Springer LNCS (to appear), 1995.

[BGS88]

H. Bertling, H. Ganzinger, and R. Schäfers. Cec: A system for conditional equational completion - user manual (version 1.0). report, prospectra-project, u. dortmund, 1988.

[BGS91]

H. Bertling, H. Ganzinger, and R. Schäfers. Completion. Draft for final PROSPECTRA documentation, Univ. Dortmund, 1991.

[BGW92]

L. Bachmair, H. Ganzinger, and U. Waldmann. Set constraints are the monadic class. Technical report mpi-i-92-240, MPI Informatik, 1992.

[BGW93]

L. Bachmair, H. Ganzinger, and U. Waldmann. Superposition with simplification as a decision procedure for the monadic class with equality. Technical report mpi-i-93-204, MPI Informatik, 1993.

[BH92]

F. Bueno and M. Hermenegildo. An automatic translation scheme from prolog to the andorra kernel language. In Proc. of the 1992 International Conference on Fifth Generation Computer Systems, pages 759-769. ICOT, 1992.

[BHPS90]

C. Beierle, U. Hedtstück, U. Pletat, and J. Siekmann. An order-sorted logic for knowledge representation systems. Iwbs report 113, IBM Germany, 1990.

[BJ88]

M. Bruynooghe and G. Janssens. An instance of abstract interpretation integrating type and mode inferencing. In Proc. 5th Conference on Logic Programming & 5th Symposium on Logic Programming (Seattle), pages 669-683, 1988.

[BJCD87]

M. Bruynooghe, G. Janssens, A. Callebaut, and B. Demoen. Abstract interpretation: towards the global optimization of prolog programs. In Proc. 4th IEEE Internat. Symposium on Logic Programming, pages 192-204, San Francisco, 1987.

[BJMS88]

A. Bondorf, N.D. Jones, T. Mogensen, and P. Sestoft. Binding time analysis and the taming of self-application. DIKU, 1988.

[BK82]

K.A. Bowen and R.A. Kowalski. Amalgamating language and metalanguage in logic programming. In K.L. Clark and S.-A. T{ärnlund, editors, Logic Programming, pages 153-172. Academic Press, 1982.

[BK85]

H. Boley and F. Kammermeier. Lisplog: Momentaufnahmen einer lisp/prolog-vereinheitlichung. Memo seki-85-3, Univ. Kaiserslautern, 1985.

[BK86]

J.A. Bergstra and J.W. Klop. Conditional rewrite rules: Confluence and termination. Journal of Computer and System Sciences, 32(3):323-362, 1986.

[BK95]

G.H. Botorog and H. Kuchen. Algorithmic skeletons in an imperative language for distributed programming. Technical report, Univ. Giessen, 1995.

[BK96]

A. Brüll and H. Kuchen. Tpascal - a language for task parallel programming. Report 9601, Univ. Giessen, 1996.

[BK98]

G.H. Botorog and H. Kuchen. Efficient high-level parallel programming. Theoretical Computer Science 196, pages 71-107, 1998.

[BKL+97]

S. Breitinger, U. Klusik, R. Loogen, Y. Ortega-Mallén, and R. Pe\ na. Dream: The disributed eden abstract machine. In Proc. 9th International Workshop on Implementation of Functional Languages (IFL'97), pages 250-269. Springer LNCS 1467, 1997.

[BKL98]

S. Breitinger, U. Klusik, and R. Loogen. From (sequential) haskell to (parallel) eden: An implementation point of view. In Principles of Declarative Programming (Proc. Joint International Symposium PLILP/ALP'98), pages 318-334. Springer LNCS 1490, 1998.

[BKSZ87a]

R. Budde, K. Kuhlenkamp, K.-H. Sylla, and H. Züllighoven. Constructing interactive applications in a prolog programming environment. Internal report, GMD, 1987.

[BKSZ87b]

R. Budde, K. Kuhlenkamp, K.-H. Sylla, and H. Züllighoven. Eine übersicht über die prolog-programmierumgebung prolab. Jahresbericht 1987, GMD, 1987.

[BKSZ87c]

R. Budde, K. Kuhlenkamp, K.-H. Sylla, and H. Züllighoven. Methodik des programmierens in prolog. GMD Projekt ProLab, 1987.

[BKW92]

A. Bockmayr, S. Krischer, and A. Werner. An optimal narrowing strategy for general canonical systems. In Proc. of the 3rd Intern. Workshop on Conditional Term Rewriting Systems, pages 483-497. Springer LNCS 656, 1992.

[BKW93]

A. Bockmayr, S. Krischer, and A. Werner. Narrowing strategies for arbitrary canonical rewrite systems. Technical report mpi-i-93-233, Max-Planck-Institut f{ür Informatik, Saarbr{ücken, 1993.

[BL79]

G. Berry and J.-J. Lévy. Minimal and optimal computations of recursive programs. Journal of ACM, 26(1):148-175, 1979.

[BL86]

M. Bellia and G. Levi. The relation between logic and functional languages: A survey. Journal of Logic Programming (3), pages 217-236, 1986.

[BL89]

K. Benkerimi and J.W. Lloyd. A procedure for the partial evaluation of logic programs. Report tr-89-04, University of Bristol, 1989.

[BL93]

S. Breitinger and H.C.R. Lock. Solving industrial scheduling problems with finite domain constraints. IBM Deutschland, 1993.

[BLM90]

M. Bugliesi, E. Lamma, and P. Mello. Partial deduction for structured logic programming, 1990.

[Blo84]

C. Bloch. Source-to-source transformations of logic programs. Technical report, Weizmann Institue of Science, Rehovot, 1984.

[BLOM95a]

S. Breitinger, R. Loogen, and Y. Ortega-Mallen. Concurrency in functional and logic programming. In Fuji International Workshop on Functional and Logic Programming. World Scientific Publ., 1995.

[BLOM95b]

S. Breitinger, R. Loogen, and Y. Ortega-Mallen. Towards a declarative language for parallel and concurrent programming. In Glasgow Workshop on Functional Programming, 1995.

[BLOMPM96]

S. Breitinger, R. Loogen, Y. Ortega-Mallen, and R. Pena-Mari. Eden - the paradise of concurrent functional programming. In Proc. Europar'96. Springer LNCS 1123, 1996.

[BM72]

R.S. Boyer and J.S. Moore. The sharing of structure in theorem proving programs. In B. Meltzer and D. Michie, editors, Machine Intelligence 7, pages 101-116, 1972.

[BM86]

J. Barklund and H. Millroth. Garbage cut for garbage collection of iterative prolog programs. In Proc. IEEE Internat. Symposium on Logic Programming, pages 276-283, Salt Lake City, 1986.

[BM88a]

R. Barbuti and M. Martelli. A tool to check the non-floundering logic programs and goals. In Proc. of the Workshop on Programming Language Implementation and Logic Programming, pages 58-67, Orléans, 1988. Springer LNCS 348.

[BM88b]

S. Bonnier and J. Maluszynski. Towards a clean amalgamation of logic programs with external procedures. In Proc. 5th Conference on Logic Programming & 5th Symposium on Logic Programming (Seattle), pages 311-326. MIT Press, 1988.

[BM89]

F. Bry and R. Manthey. Deductive databases. Tutorial notes at ICLP'89, 1989.

[BM93]

C. Beierle and G. Meyer. Run-time type computations in the warren abstract machine. Informatik-bericht 144-8/1993, FernUniversit{ät Hagen, 1993. Also to appear in Journal of Logic Programming.

[BM96]

R. Barbuti and P. Mancarella. A multiple-valued logical semantics for prolog. In Proc. ESOP'96, pages 62-76. Springer LNCS 1058, 1996.

[BMM+88]

B. Bertolino, P. Mancarella, L. Meo, L. Nini, D. Pedreschi, and F. Turini. A progress report on the lml project. In Proc. FGCS'88, pages 675-684, 1988.

[BMPP89]

F.L. Bauer, B. Möller, H. Partsch, and P. Pepper. Formal program construction by transformations - computer-aided, intuition-guided programming. IEEE Transactions on Software Engineering, 15(2):165-179, 1989.

[BMPT87]

R. Barbuti, P. Mancarella, D. Pedreschi, and F. Turini. Intensional negation of logic programs: Examples and implementation techniques. In Proc. of the TAPSOFT '87, pages 96-110. Springer LNCS 250, 1987.

[BMPT90]

R. Barbuti, P. Mancarella, D. Pedreschi, and F. Turini. A transformational approach to negation in logic programming. Journal of Logic Programming (8), pages 201-228, 1990.

[BMPT91]

B. Bertolino, L. Meo, D. Pedreschi, and F. Turini. The logical meta-language lml and its type system. To appear in Types in Logic Programming, 1991.

[BMPT94]

A. Brogi, P. Mancarella, D. Pedreschi, and F. Turini. Modular logic programming. ACM Transactions on Programming Languages and Systems, 16(4):1361-1398, 1994.

[BMS80]

R.M. Burstall, D.B. MacQueen, and D.T. Sannella. Hope: An experimental applicative language. In Conference Record of the 1980 LISP Conference, pages 136-143. ACM, 1980.

[BMS91]

C. Beierle, G. Meyer, and H. Semle. Extending the warren abstract machine to polymorphic order-sorted resolution. In Proc. International Logic Programming Symposium, pages 272-286. MIT Press, 1991.

[BN77]

E. Bergmann and H. Noll. Mathematische Logik mit Informatik-Anwendungen. Springer, 1977.

[BN98]

F. Baader and T. Nipkow. Term Rewriting and All That. Cambridge University Press, 1998.

[BO97]

F. Benhamou and W.J. Older. Applying interval arithmetic to real, integer, and boolean constraints. Journal of Logic Programming, 32(1):1-24, 1997.

[Bob84]

D.G. Bobrow. If prolog is the answer, what is the question?. In Proc. FGCS'84, pages 138-145, 1984.

[Boc86]

A. Bockmayr. Conditional rewriting and narrowing as a theoretical framework for logic-functional programming. Technical report 10/86, Univ. Karlsruhe, 1986.

[Boc88]

A. Bockmayr. Narrowing with built-in theories. In Proc. First International Workshop on Algebraic and Logic Programming (Gaussig, G.D.R.), pages 83-92. Springer LNCS 343, 1988.

[Boc93a]

A. Bockmayr. Conditional narrowing modulo a set of equations. Applicable Algebra in Engineering, Communication and Computing, 4(3):147-168, 1993.

[Boc93b]

A. Bockmayr. Logic programming with psuedo-boolean constraints. In F. Benhamou and A. Colmerauer, editors, Constraint Logic Programming, pages 327-350. MIT Press, 1993.

[Boe89]

H.-J. Boehm. Type inference in the presence of type abstraction. In Proc. SIGPLAN '89 PLDI, pages 192-206. SIGPLAN Notices Vol. 24, No. 7, 1989.

[Boi86]

P. Boizumault. A general model to implement dif and freeze. In Proc. Third International Conference on Logic Programming (London), pages 585-592. Springer LNCS 225, 1986.

[Bol90a]

R.N. Bol. Generalizing completeness results for loop checks. Report cs-r9025, CWI Amsterdam, 1990.

[Bol90b]

R.N. Bol. Loop checking and negation. Report cs-r9075, CWI Amsterdam, 1990.

[Bol90c]

R.N. Bol. Towards more efficient loop checks. Report cs-r9026, CWI Amsterdam, 1990.

[Bol90d]

H. Boley. A relational/functional language and its compilation into the wam. Seki report sr-90-05, Univ. Kaiserslautern, 1990.

[Bol92]

H. Boley. A direct semantic characterization of relfun. Research report rr-92-54, DFKI, 1992.

[Bol93]

H. Boley. A sampler of relational/functional definitions. Technical memo tm-91-04, DFKI, 1993.

[Bol96]

H. Boley. Declarative specification of the chemical elements in the relational-functional language relfun. Slides of a talk at Dagstuhl-Seminar 9621, 1996.

[Bon88]

A. Bondorf. Pattern matching in a self-applicable partial evaluator. DIKU, 1988.

[Bon90]

S. Bonnier. Horn clause logic with external procedures: Towards a formal framework. Link{öping University, 1990.

[Bon91]

S. Bonnier. Unification in incompletely specified theories: A case study. In Mathematical Foundations of Computer Science, pages 84-92. Springer LNCS 520, 1991.

[Bon92]

S. Bonnier. A Formal Basis for Horn Clause Logic with External Polymorphic Functions. PhD thesis, Link{öping University, 1992.

[Boo91]

G. Booch. Object Oriented Design with Applications. Benjamin/Cummings, 1991.

[Boo92]

G. Booch. The booch method: Notation. Published by Rational, 1992.

[B{ör87]

E. Börger. Unsolvable decision problems for prolog programs. In Computation Theory and Logic, pages 37-48. Springer LNCS 270, 1987.

[B{ör90a]

E. Börger. A logical operational semantics of full prolog. part i: Selection core and control. In Proc. CSL'89, pages 36-64. Springer LNCS 440, 1990.

[B{ör90b]

E. Börger. A logical operational semantics of full prolog. part ii: Built-in predicates for database manipulations. In Mathematical Foundations of Computer Science '90, pages 1-14. Springer LNCS 452, 1990.

[BOS91]

P. Butterworth, A. Otis, and J. Stein. The gemstone object database management system. Communications of the ACM, 34(10):64-77, 1991.

[B{öt90]

S. Böttcher. Development and programming of deductive databases with protos-l. Iwbs report 118, IBM Deutschland, 1990.

[Bou92]

F. Bourdoncle. Abstract interpretation by dynamic partitioning. Research report 18, DEC Paris Research Laboratory, 1992.

[Bou95]

D. Boulanger. Decoding models of definite logic programs. Technical report, GMD FIRST, 1995.

[Bow91]

J. Bowen. From programs to object code using logic and logic programming. In Proc. Int. Workshop on Code Generation, Dagstuhl, 1991.

[Boy91]

J. Boye. S-sld-resolution - an operational semantics for logic programs with external procedures. In Proc. of the 3rd Int. Symposium on Programming Language Implementation and Logic Programming, pages 383-393. Springer LNCS 528, 1991.

[Boy93]

J. Boye. Avoiding dynamic delays in functional logic programs. In Proc. of the 5th International Symposium on Programming Language Implementation and Logic Programming, pages 12-27. Springer LNCS 714, 1993.

[BP88a]

C. Beierle and U. Pletat. Feature graphs and abstract data types: A unifying approach. Lilog-report 39, IBM Deutschland, 1988.

[BP88b]

C. Beierle and U. Pletat. Semantics of logic programs with equational abstract data type specifications. Lilog-report 38, IBM Deutschland, 1988.

[BP89]

C. Beierle and U. Pletat. The algebra of feature graph specifications. Iwbs report 94, IBM Deutschland, 1989.

[BPM93a]

J. Boye, J. Paakki, and J. Maluszynski. Dependency-based groundness analysis of functional logic programs. Research report lith-ida-r-93-20, Link{öping University, 1993.

[BPM93b]

J. Boye, J. Paakki, and J. Maluszynski. Synthesis of directionality information for functional logic programs. In Proc. Third International Workshop on Static Analysis, pages 165-177. Springer LNCS 724, 1993.

[BPU88]

C. Beierle, U. Pletat, and H. Uszkoreit. An algebraic characterization of stuf. Lilog report 40, IBM Deutschland, 1988.

[BR89]

M. Bugliesi and F. Russo. Partial evaluation in prolog: Some improvements about cut. In Proc. of the 1989 North American Conference on Logic Programming, pages 645-660. MIT Press, 1989.

[BR90]

E. Börger and D. Rosenzweig. From prolog algebras towards wam - a mathematical study of implementation. In CSL'90. Springer LNCS, 1990.

[BR91a]

E. Börger and D. Rosenzweig. An analysis of prolog database views and their uniform implementation. Report cse-tr-89-91, Univ. of Michigan, 1991.

[BR91b]

E. Börger and D. Rosenzweig. A formal specification of prolog by tree algebras. In Proc. of ITI, 1991.

[BR91c]

P. Brisset and O. Ridoux. Naive reverse can be linear. In Proc. International Conference on Logic Programming, pages 857-870. MIT Press, 1991.

[BR92a]

E. Börger and D. Rosenzweig. A simple mathematical model for full prolog. Technical report tr-33/92, Univ. Pisa, 1992.

[BR92b]

E. Börger and D. Rosenzweig. The wam - definition and compiler correctness. Technical report tr-14/92, Univ. Pisa, 1992.

[Bri94]

P. Brisset. Avoiding dynamic type checking in a polymorphic logic programming language. Technical report, IRISA (Rennes), 1994.

[Bri96]

D. Briaud. Higher order unification as a typed narrowing. Technical report, CNRS and INRIA Lorraine, 1996.

[Bri97]

D. Briaud. Explicit substitutions and preunification: a simple approach. Technical report, INRIA Lorraine, 1997.

[BRNN]

W. Bousdira and J.-L. Remy. Hierarchical contextual rewriting with several levels. CRIN & INRIA Lorraine, NN.

[Bro80]

M. Broy. Zur spezifikation von programmen für die textverarbeitung. In P.R. Wossidlo, editor, Textverarbeitung und Informatik, pages 75-93. Springer, 1980.

[Bro88a]

K.P. Brooks. A two-view document editor with user-definable document structure. Technical report 33, DEC Palo Alto, 1988.

[Bro88b]

M. Broy. Equational specification of partial higher-order algebras. Theoretical Computer Science, 57:3-45, 1988.

[Bro93]

A. Brogi. Program Construction in Computational Logic. PhD thesis, Univ. Pisa, 1993. Appeared as Technical Report TD-2/93.

[Bru82]

M. Bruynooghe. The memory management of prolog implementations. In K.L. Clark and S.-A. {Tärnlund}, editors, Logic Programming, pages 83-98. Academic Press, 1982.

[Bru84]

M. Bruynooghe. Garbage collection in prolog interpreters. In J.A. Campbell, editor, Implementations of Prolog, pages 259-267. Ellis Horwood, 1984.

[Bru91]

M. Bruynooghe. A practical framework for the abstract interpretation of logic programs. Journal of Logic Programming (10), pages 91-124, 1991.

[BS87]

W. Büttner and H. Simonis. Embedding boolean expressions into logic programming. Journal of Symbolic Computation, 4:191-205, 1987.

[BS92a]

R. Backofen and G. Smolka. A complete and recursive feature theory. Research report rr-92-30, DFKI Saarbr{ücken, 1992.

[BS92b]

N. Baker and H. Søndergaard. Definiteness analysis for clp($\cal r$). Technical report 92/25, Univ. of Melbourne, 1992.

[BS94]

F. Baader and J.H. Siekmann. Unification theory. In D.M. Gabbay, C.J. Hogger, and J.A. Robinson, editors, Handbook of Logic in Artificial Intelligence and Logic Programming, pages 41-125. Oxford University Press, 1994.

[BS98a]

E. Börger and W. Schulte. Defining the java virtual machine as platform for provably correct java compilation. In Proc. MFCS'98, 1998.

[BS98b]

E. Börger and W. Schulte. A programmer friendly modular definition of the semantics of java. In Formal Syntax and Semantics of Java. Springer LNCS, 1998.

[BT88]

V. Breazu-Tannen. Combining algebra and higher-order types. In Proc. LICS'88, 1988.

[BT93]

M. Burke and L. Torczon. Interprocedural optimization: Eliminating unnecessary recompilation. ACM Transactions on Programming Languages and Systems, 15(3):367-399, 1993.

[BT94]

B. Bütow and S. Thesing. Reverse restructuring: Another method of solving algebraic equations. Report 94-07, Univ. Bielefeld, 1994.

[BT95]

Y. Bekkers and P. Tarau. Monadic constructs for logic programming. In Proc. of the 1995 International Logic Programming Symposium, pages 51-65. MIT Press, 1995.

[BTM85]

V. Breazu-Tannen and A.R. Meyer. Lambda calculus with constrained types. In Logic of Programs '85. Springer LNCS 193, 1985.

[Buc96]

B. Buchberger. Proving, solving, computing. In JICSLP'96-Workshop on Multi-Paradigm Logic Programming, 1996.

[Bud91]

T. Budd. An Introduction to Object-Oriented Programming. Addison-Wesley, 1991.

[Bud98]

T.A. Budd. Functional programming and the fragile base class problem. ACM SIGPLAN Notices, 33(12):66-71, 1998.

[Bue86]

K.A. Buettner. Fast decompilation of compiled prolog clauses. In Proc. Third International Conference on Logic Programming (London), pages 663-670. Springer LNCS 225, 1986.

[Bun88]

A. Bundy. A broader interpretation of logic in logic programming. In Proc. 5th Conference on Logic Programming & 5th Symposium on Logic Programming (Seattle), pages 1624-1648. MIT Press, 1988.

[Bur89]

F.W. Burton. A note in higher-order functions versus logical variables. Information Processing Letters, 31:91-95, 1989.

[Bur91]

W. Burgard. Goal-Directed Forward Chaining for Logic Programs. PhD thesis, Univ. Bonn, 1991.

[B{üt88]

W. Büttner. Application driven prolog extensions. Siemens AG, 1988.

[B{üt92]

B. Bütow. Konzepte zur parallelisierung logisch-funktionaler programmiersprachen. Diplomarbeit, Univ. Dortmund, 1992.

[BvEG+87]

H.P. Barendregt, M.C.J.D. van Eekelen, J.R.W. Glauert, J.R. Kennaway, M.J. Plasmeijer, and M.R. Sleep. Term graph rewriting. In Proc. Parallel Architectures and Languages Europe (PARLE'87), pages 141-158. Springer LNCS 259, 1987.

[BW88]

R.S. Bird and P. Wadler. Introduction to Functional Programming. Prentice Hall, 1988.

[BW92a]

D.A. Basin and T. Walsh. Difference matching. Report mpi-i-92-211, Max-Planck-Institut f{ür Informatik, Saarbr{ücken, 1992.

[BW92b]

M. Bruynooghe and W. Winsborough. Type graph unification. Technical report cw 160, K.U. Leuven, 1992.

[BYG92]

R. Baeza-Yates and G.H. Gonnet. A new approach to text searching. Communications of the ACM, 35(10):74-82, 1992.

[Byr80]

L. Byrd. Understanding the control flow of prolog programs. In Proc. of the Workshop on Logic Programming, Debrecen, 1980.

[Cam84]

J.A. Campbell. Implementations of Prolog. Ellis Horwood, 1984.

[Car84]

M. Carlsson. On implementing prolog in functional programming. In Proc. IEEE Internat. Symposium on Logic Programming, pages 154-159, Atlantic City, 1984.

[Car87a]

L. Cardelli. Building user interfaces by direct manipulation. Technical report 22, DEC Palo Alto, 1987.

[Car87b]

M. Carlsson. Freeze, indexing, and other implementation issues in the wam. In Proc. Fourth International Conference on Logic Programming (Melbourne), pages 40-58. MIT Press, 1987.

[Car88]

L. Cardelli. Structural subtyping and the notion of power type. In Proc. POPL'88, 1988.

[Cas91]

Y. Caseau. Abstract interpretation of constraints on order-sorted domains. In Proc. 1991 International Logic Programming Symposium, pages 435-452. MIT Press, 1991.

[Cas95]

G. Castagna. Covariance and contravariance: Conflict without a cause. ACM Transactions on Programming Languages and Systems, 17(3):431-447, 1995.

[Cav88]

L. Cavedon. On the completeness of sldnf-resolution. Technical report 88/17, Univ. of Melbourne, 1988.

[CB83]

J. Corbin and M. Bidoit. A rehabilitation of robinson's unification algorithm. In Proc. IFIP '83, pages 909-914. North-Holland, 1983.

[CBGdlBH97]

M. Codish, M. Bruynooghe, M. Garc\'\ia de la Banda, and M. Hermenegildo. Exploiting goal independence in the analysis of logic programs. Journal of Logic Programming, 32(3):247-161, 1997.

[CBH85]

V.S. Cherniavsky, H. Broer, and U. Hafermann. Programmieren in apl. Informatik-skripten 12, TU Braunschweig, 1985.

[CC77]

P. Cousot and R. Cousot. Abstract interpretation: A unified lattice model for static analysis of programs by construction of approximation of fixpoints. In Proc. of the 4th ACM Symposium on Principles of Programming Languages, pages 238-252, 1977.

[CC79]

P. Cousot and R. Cousot. Systematic design of program analysis frameworks. In Proc. 6th ACM Symposium on Principles of Programming Languages, pages 269-282, 1979.

[CC92a]

P. Cousot and R. Cousot. Abstract interpretation and application to logic programs. Rapport de recherche lix/rr/92/08, LIX, Ecole Polytechniqe (Palaiseau, France), 1992. Also appeared in Journal of Logic Programming (1992).

[CC92b]

P. Cousot and R. Cousot. Comparing the galois connection and widening/narrowing approaches to abstract interpretation. Research report lix/rr/92/09, Ecole Polytechnique, Palaiseau (France), 1992.

[CCC90]

C. Codognet, P. Codognet, and M.-M. Corsini. Abstract interpretation for concurrent logic languages. In Proc. of the 1990 North American Conference on Logic Programming, pages 215-232. MIT Press, 1990.

[CD95]

M. Codish and B. Demoen. Analyzing logic programs using ``PROP''-ositional logic programs and a magic wand. Journal of Logic Programming, 25(3):249-274, 1995.

[CD96]

P. Codognet and D. Diaz. Compiling constraints in clp(fd). Journal of Logic Programming, 27(3):185-226, 1996.

[CDD+98]

B. Cui, Y. Dong, X. Du, N. Kumar, C.R. Ramakrishnan, I.V. Ramakrishnan, A. Roychoudhury, S.A. Smolka, and D.S. Warren. Logic programming and model checking. In Principles of Declarative Programming (Proc. Joint International Symposium PLILP/ALP'98), pages 1-20. Springer LNCS 1490, 1998.

[CDFB92]

M. Codish, D. Dams, G. File, and M. Bruynooghe. Freeness analysis for logic programs - and correctness?. Technical report cw 161, K.U. Leuven, 1992.

[CDG+88]

L. Cardelli, J. Donahue, L. Glassman, M. Jordan, B. Kalsow, and G. Nelson. Modula-3 report. Technical report, Digital Systems Research Center, 1988.

[CDG93]

M. Codish, S.K. Debray, and R. Giacobazzi. Compositional analysis of modular logic programs. In Proc. POPL'93, 1993.

[CDG+95]

L. Cardelli, J. Donahue, L. Glassman, M. Jordan, B. Kalsow, and G. Nelson. Modula-3 language definition. Part of Nelson's book, 1995.

[CDY90]

M. Codish, D. Dams, and E. Yardeni. Bottom-up abstract interpretation of logic programs, 1990.

[CDY94]

M. Codish, D. Dams, and E. Yardeni. Bottom-up abstract interpretation of logic programs. Theoretical Computer Science 124, pages 93-125, 1994.

[CF88]

T. Conrad and U. Furbach. Sorts are nothing but functions. an equational approach to sorts for logic programming. Report fki-89-88, Techn.\ Univ.\ {München}, 1988.

[CF90]

P.H. Cheong and L. Fribourg. Integrating simplification into prolog. Draft, LIENS, Paris, 1990.

[CF91a]

P.H. Cheong and L. Fribourg. Efficient integration of simplification into prolog. In Proc. of the 3rd Int. Symposium on Programming Language Implementation and Logic Programming, pages 359-370. Springer LNCS 528, 1991.

[CF91b]

P.H. Cheong and L. Fribourg. A survey of the implementations of narrowing. In J. Darlington and R. Dietrich, editors, Workshop on Declarative Programming, pages 177-187. Springer, Workshops in Computing, 1991.

[CF91c]

A. Cortesi and G. File. Abstract interpretation of logic programs: an abstract domain for groundness, sharing, freeness and compoundness analysis. In ACM Symposium on Partial Evaluation and Semantics-Based Program Manipulation PEPM'91, pages 52-61. SIGPLAN Notices Vol. 26, No. 9, 1991.

[CF93]

P.H. Cheong and L. Fribourg. Implementation of narrowing: The prolog-based approach. In K.R. Apt, J.W. de Bakker, and J.J.M.M. Rutten, editors, Logic programming languages: constraints, functions, and objects, pages 1-20. MIT Press, 1993.

[CFL+88]

P. Coscia, P. Franceschi, G. Levi, G. Sardu, and L. Torre. Meta-level definition and compilation of inference engines in the epsilon logic programming environment. In Proc. 5th Conference on Logic Programming & 5th Symposium on Logic Programming (Seattle), pages 359-373, 1988.

[CFM94]

M. Codish, M. Falaschi, and K. Marriott. Suspension analyses for concurrent logic programs. ACM Transactions on Programming Languages and Systems, 16(3):649-686, 1994.

[CFMW93]

M. Codish, M. Falaschi, K. Marriott, and W. Winsborough. Efficient analysis of concurrent constraint logic programs. In Proc. ICALP'93. Springer LNCS, 1993.

[CFR92a]

A. Cortesi, G. File, and S. Rossi. Abstract interpretation of prolog programs with cut and built-ins. Univ. of Padova, 1992.

[CFR92b]

A. Cortesi, G. File, and S. Rossi. Abstract interpretation of prolog: the treatment of the built-ins. In Proc. GULP'92, pages 87-103, 1992.

[CFW91]

A. Cortesi, G. File, and W. Winsborough. \em Prop revisited: Propositional formula as abstract domain for groundness analysis. In Proc. IEEE Symposium on Logic in Computer Science, pages 322-327, 1991.

[CFW92]

A. Cortesi, G. File, and W. Winsborough. Comparison of abstract interpretations. In Proc. ICALP'92, pages 521-532, 1992.

[CFW96]

A. Cortesi, G. Filé, and W. Winsborough. Optimal groundness analysis using propositional logic. Journal of Logic Programming, 27(2):137-167, 1996.

[CG89]

N. Carriero and D. Gelernter. Linda in context. Communications of the ACM, 32(4):444-458, 1989.

[CGK98]

M.M.T. Chakravarty, Y. Guo, and M. Köhler. Distributed haskell: Goffin on the internet. In Proc. of the Third Fuji International Symposium on Functional and Logic Programming, pages 80-97. World Scientific Publishers, 1998.

[CGKL98]

M.M.T. Chakravarty, Y. Guo, M. Köhler, and H.C.R. Lock. Goffin - higher-order functions meet concurrent constraints. Science of Computer Programming, 30(1-2):157-199, 1998.

[CGS89]

M.A. Casanova, R.A. de T. Guerreiro, and A. Silva. Computing answer to logic programs with weak model elimination. In Proc. of the 1989 North American Conference on Logic Programming, pages 92-114. MIT Press, 1989.

[CH87]

J. Cohen and T.J. Hickey. Parsing and compiling using prolog. ACM Transactions on Programming Languages and Systems, 9(2):125-163, 1987.

[CH93]

M. Carlsson and T. Hallgren. Fudgets - a graphical user interface in a lazy functional language. In Conference on Functional Programming and Computer Architecture (FPCA'93). ACM Press, 1993.

[CH96]

D. Cabeza and M. Hermenegildo. Internet and www programming using computational logic systems. In Workshop on Logic Programming and the Internet, 1996. See also http://www.clip.dia.fi.upm.es/miscdocs/pillow/pillow.html.

[Cha88]

D. Chan. Constructive negation based on the completed database. In Proc. 5th Conference on Logic Programming & 5th Symposium on Logic Programming (Seattle), pages 111-125, 1988.

[Che87]

W. Chen. A theory of modules based on second-order logic. In Proc. 4th IEEE Internat. Symposium on Logic Programming, pages 24-33, San Francisco, 1987.

[Che90]

P.H. Cheong. Compiling lazy narrowing into prolog. Technical report 25, LIENS, Paris, 1990. To appear in Journal of New Generation Computing.

[Chi95]

T. Chikayama. Structure of klic. Slides presented at ICLP'95, 1995.

[Chr83]

B. Christensen. Comal-80. LOG IN 3, 1983.

[Chr88]

H. Christiansen. Extensible logic for extensible languages. Roskilde Univ., 1988.

[Chr92]

J. Christian. Some termination criteria for narrowing and e-narrowing. In Proc. CADE-11, pages 582-588. Springer LNCS, 1992.

[Chu40]

A. Church. A formulation of the simple theory of types. Journal of Symbolic Logic, 5:56-68, 1940.

[CIR87]

W. Correnz, J. Ingenerf, and M.M. Richter. Bemerkungen über ml und seine polymorphe typstruktur. Informationstechnik it, 29(4):235-240, 1987.

[Civ93]

F. Civello. Roles for composite objects in object-oriented analysis and design. In Proc. OOPSLA'93, pages 376-393. ACM SIGPLAN Notices Vol. 28, No. 10, 1993.

[CK84]

R.H. Campbell and P.A. Kirslis. The saga project: A system for software development. In ACM, 1984.

[CK92]

M.M.T. Chakravarty and M. Köhler. Equational constraints, residuation, and the parallel jump-machine. In Proc. 4th Int. Workshop on the Parallel Implementation of Functional Languages (Aachen), 1992.

[CKH93]

W.-N. Chin, A. Kumar, and M. Hagiya. Tupling and lambda abstraction yield dynamic-sized tabulation, 1993.

[CKP+96]

D.E. Culler, R.M. Karp, D. Patterson, A. Sahay, E.E. Santos, K.E. Schauser, R. Subramonian, and T. von Eicken. Logp: A practical model of parallel computation. Communications of the ACM, 39(11):79-85, 1996.

[CKS+81]

D.D. Chamberlin, J.C. King, D.R. Slitz, S.J.P. Todd, and B.W. Wade. Janus: An interactive system for document composition. In Proc. ACM SIGPLAN SIGOA Symposium on Text Manipulation, Portland/Oregon, pages 82-91. SIGOA Newsletter, Vol. 2, No. 1+2, 1981.

[CKW89]

W. Chen, M. Kifer, and D.S. Warren. Hilog: A first-order semantics for higher-order logic programming constructs. In Proc. of the 1989 North American Conference on Logic Programming, pages 1090-1114. MIT Press, 1989.

[CL73]

C.-L. Chang and R.C.-T. Lee. Symbolic Logic and Mechanical Theorem Proving. Academic Press, 1973.

[CL89]

H. Comon and P. Lescanne. Equational problems and disunification. J. Symbolic Computation, 7:371-425, 1989.

[CL91]

M.M.T. Chakravarty and H.C.R. Lock. The implementation of lazy narrowing. In Proc. of the 3rd Int. Symposium on Programming Language Implementation and Logic Programming, pages 123-134. Springer LNCS 528, 1991.

[CL94]

M.M.T. Chakravarty and H.C.R. Lock. The jump-machine: a generic basis for the integration of declarative paradigms. In Proc. Post-ICLP'94 Workshop on Integration of Declarative Paradigms, pages 61-75. Technical Report MPI-I-94-224, MPI Informatik, Saarbr{ücken, 1994.

[CL95]

M. Codish and V. Lagoon. Analyzing logic programs for real: A persistent type analysis. Technical report, Ben-Gurion University, 1995.

[CL97a]

Y. Caseau and F. Laburthe. Solving various weighted matching problems with constraints. In Principles and Practice of Constraint Programming, pages 17-31. Springer LNCS 1330, 1997.

[CL97b]

M.M.T. Chakravarty and H.C.R. Lock. Towards the uniform implementation of declarative languages. Computer Languages, 23(2-4):121-160, 1997.

[CL00]

K. Claessen and P. Ljunglöf. Typed logical variables in haskell. In Proc. ACM SIGPLAN Haskell Workshop, Montreal, 2000.

[Cla78]

K.L. Clark. Negation as failure. In H. Gallaire and J. Minker, editors, Logic and Data Bases, pages 293-322. Plenum Press, 1978.

[CLF99]

R. Caballero and F.J. López-Fraguas. A functional-logic perspective of parsing. In Proc. 4th Fuji International Symposium on Functional and Logic Programming (FLOPS'99), pages 85-99. Springer LNCS 1722, 1999.

[CLMN88]

M. Cavalieri, E. Lamma, P. Mello, and A. Natali. Meta-programming in prolog through direct introspection: A comparison with meta-interpretation techniques. In Proc. META'88, pages 399-415. MIT Press, 1988.

[Clo85a]

W.F. Clocksin. Design and simulation of a sequential prolog machine. New Generation Computing, 3(1):101-120, 1985.

[Clo85b]

W.F. Clocksin. Implementation techniques for prolog databases. Software - Practice and Experience, 15(7):669-675, 1985.

[CLS91]

H. Comon, D. Lugiez, and Ph. Schnoebelen. A rewrite-based type discipline for a subset of computer algebra. Journal of Symbolic Computation, 11:349-368, 1991.

[CM87]

W.F. Clocksin and C.S. Mellish. Programming in Prolog. Springer, third rev. and ext. edition, 1987.

[CMB+92]

M. Codish, A. Mulkers, M. Bruynooghe, M. Garcia de la Banda, and M. Hermenegildo. Improving abstract interpretation by combining domains. Technical report cw 162, K.U. Leuven, 1992. Also in Proc. ACM Symposium on Partial Evaluation and Semantics-Based Program Manipulation '93, pp. 194-206.

[CMB+95]

M. Codish, A. Mulkers, M. Bruynooghe, M. Garcia de la Banda, and M. Hermenegildo. Improving abstract interpretations by combining domains. ACM Transactions on Programming Languages and Systems, 17(1):28-44, 1995.

[CMW93]

J.N. Crossley, L. Mandel, and M. Wirsing. Untyped constrained lambda calculus. Technical report, LMU M{ünchen, 1993.

[CNSvS94]

T. Coquand, B. Nordström, J.M. Smith, and B. von Sydow. Type theory and programming. Bulletin of the EATCS, No. 52, pages 203-228, 1994.

[Coa92]

P. Coad. Object-oriented patterns. Communications of the ACM, 35(9):152-159, 1992.

[Coh85]

J. Cohen. Describing prolog by its interpretation and compilation. Communications of the ACM, 28(12):1311-1324, 1985.

[Coh88]

J. Cohen. A view of the origins and development of prolog. Communications of the ACM, 31(1):26-36, 1988.

[Coh90]

J. Cohen. Constraint logic programming languages. Communications of the ACM, 33(7):52-68, 1990.

[Col78]

A. Colmerauer. Metamorphosis grammars. In Natural language communication with computers, pages 133-189. Springer LNCS 63, 1978.

[Col82]

A. Colmerauer. Prolog and infinite trees. In K.L. Clark and S.-A. T{ärnlund, editors, Logic Programming, pages 231-251. Academic Press, 1982.

[Col85]

A. Colmerauer. Prolog in 10 figures. Communications of the ACM, 28(12):1296-1310, 1985.

[Col90]

A. Colmerauer. An introduction to prolog iii. Communications of the ACM, 33(7):69-90, 1990.

[Col96]

Y. Colombani. Constraint programming: an efficient and practical approach to solving the job-shop problem. In Principles and Practice of Constraint Programming, pages 149-163. Springer LNCS 1118, 1996.

[Com90]

H. Comon. Solving inequations in term algebras. In Proc. Logic in Computer Science (LICS'90), pages 62-69, 1990.

[Com91]

H. Comon. Completion of rewrite systems with membership constraints. Lri rapport de recherche no. 699, Univ. Paris-Sud, 1991.

[Com92]

H. Comon. On unification of terms with integer exponents. Rapport de recherche no. 770, Univ. Paris-Sud, LRI, 1992.

[Con88]

J.S. Conery. Logical objects. In Proc. 5th Conference on Logic Programming & 5th Symposium on Logic Programming (Seattle), pages 420-434, 1988.

[Cou90]

G. Cousineau. The categorical abstract machine. In G. Huet, editor, Logical Foundations of Functional Programming, pages 25-45. Addison Wesley, 1990.

[Cou97]

P. Cousot. Types as abstract interpretations. In Proc.\ of the 24th ACM Symposium on Principles of Programming Languages (Paris), pages 316-331, 1997.

[CPT92]

S. Cabasino, P.S. Paolucci, and G.M. Todesco. Dynamic parsers and evolving grammars. ACM SIGPLAN Notices, 27(11):39-48, 1992.

[CR88]

W. Clinger and J. Rees. Revised$^4$ report on the algorithmic language scheme. Technical report, ??, 1988.

[CRSHLF97]

R. Caballero-Roldán, J. Sánchez-Hernández, and F.J. López-Fraguas. User's manual for toy. Technical report sip 97/57, Universidad Complutense de Madrid, 1997.

[CS85]

M. Codish and E. Shapiro. Compiling or-parallelism into and-parallelism. Report cs85-18, Weizmann Institute of Science, Rehovot, 1985.

[CvER89]

M.H.M. Cheng, M.H. van Emden, and B.E. Richards. On warren's method for functional programming in logic. Report lp-12 dcs-122-ir, Univ. of Victoria, 1989.

[CvER90]

M.H.M. Cheng, M.H. van Emden, and B.E. Richards. On warren's method for functional programming in logic. In Proc. Seventh International Conference on Logic Programming, pages 546-560. MIT Press, 1990.

[CVM97]

K. Claessen, T. Vullinghs, and E. Meijer. Structuring graphical paradigms in tkgofer. In Proc. of the International Conference on Functional Programming (ICFP'97), pages 251-262. ACM SIGPLAN Notices Vol. 32, No. 8, 1997.

[CW85]

L. Cardelli and P. Wegner. On understanding types, data abstraction, and polymorphism. ACM Computing Surveys, 17(4):471-523, 1985.

[CW88]

W. Chen and D.S. Warren. Objects as intensions. In Proc. 5th Conference on Logic Programming & 5th Symposium on Logic Programming (Seattle), pages 404-419, 1988.

[CW91]

W. Chen and D.S. Warren. An intensional logic of (multi-arity) set abstractions. In International Conference on Logic Programming, pages 98-110. MIT Press, 1991.

[CWY91a]

V.S. Costa, D.H.D. Warren, and R. Yang. The andorra-i engine: A parallel implementation of the basic andorra model. In Proc. International Conference on Logic Programming, pages 825-839. MIT Press, 1991.

[CWY91b]

V.S. Costa, D.H.D. Warren, and R. Yang. The andorra-i preprocessor: Supporting full prolog on the basic andorra model. In Proc. International Conference on Logic Programming, pages 443-456. MIT Press, 1991.

[CY91]

P. Coad and E. Yourdon. Object-Oriented Analysis. Yourdon Press, 1991.

[CYLY87]

Z. Chenxi, T. Yungui, L. Liangliang, and H. Yunfa. An approach to the implementation of prolog code database and source database in compiler-based systems. In Proc. 4th IEEE Internat. Symposium on Logic Programming, pages 398-405, San Francisco, 1987.

[Dar91]

P.W. Dart. On derived dependencies and connected databases. Journal of Logic Programming, 11:163-188, 1991.

[Das92]

S.K. Das. Deductive Databases and Logic Programming. Addison-Wesley, 1992.

[Dav93]

A. Davison. 15th july 1972: A significant moment for logic programming. ACM SIGPLAN Notices, 28(4):58-60, 1993.

[Day88]

G. Dayantis. Types, modularisation and abstraction in logic programming. In Proc. Algebraic and Logic Programming (Gaussig). Springer LNCS 343, 1988.

[DB89]

Y. Deville and J. Burnay. Generalization and program schemata: A step towards computer-aided construction of logic programs. In Proc. of the 1989 North American Conference on Logic Programming, pages 409-425. MIT Press, 1989.

[DB97]

M. Debbabi and D. Bolignano. A semantic theory for ml higher-order concurrency primitives. In F. Nielson, editor, ML with Concurrency: Design, Analysis, Implementation, and Application, pages 145-183. Springer, 1997.

[dCLF92]

D. de Champeaux, D. Lea, and P. Faure. The process of object-oriented design. In Proc. OOPSLA'92, pages 45-62. ACM SIGPLAN Notices 27(10), 1992.

[dDCGM00]

J. de Dios Castro and J.C. González Moreno. A graphical development environment for functional logic languages. In Proc.\ of the Ninth International Workshop on Functional and Logic Programming (WFLP 2000), pages 404-417. Universidad Polit{écnica de Valencia, 2000.

[DE87]

M. Ducasse and A.-M. Emde. State of the art in automated program debugging. Technical report tr-lp-25, ECRC, 1987.

[DE91]

M. Ducasse and A.-M. Emde. Opium 3.1 - user manual. Technical report tr-lp-60, ECRC, 1991.

[Deb86]

S.K. Debray. Register allocation in a prolog machine. In Proc. IEEE Internat. Symposium on Logic Programming, pages 267-275, Salt Lake City, 1986.

[Deb88]

S.K. Debray. Efficient dataflow analysis of logic programs. In Proc. of the 15th ACM Symposium on Principles of Programming Languages, pages 260-273, San Diego, 1988.

[Deb89]

S.K. Debray. Static inference of modes and data dependencies in logic programs. ACM Transactions on Programming Languages and Systems, 11(3):418-450, 1989.

[Deb91a]

S.K. Debray. Compiler optimizations for low-level redundancy elimination: An application of meta-level prolog primitives. Report tr 91-28, Univ. of Arizona, 1991.

[Deb91b]

S.K. Debray. On the complexity of dataflow analysis of logic programs. Report tr 91-27, Univ. of Arizona, 1991.

[Deb92a]

S.K. Debray. Efficient dataflow analysis of logic programs. Journal of the ACM, 39(4):949-984, 1992.

[Deb92b]

S.K. Debray. On the complexity of dataflow analysis of logic programs. In Proc. ICALP'92, pages 509-520, 1992.

[Deb93]

S.K. Debray. Static analysis of logic programs. Tutorial at ILPS'93, 1993.

[Deb95]

S.K. Debray. On the complexity of dataflow analysis of logic programs. ACM Transactions on Programming Languages and Systems, 17(2):331-365, 1995.

[Dec86]

H. Decker. Integrity enforcement on deductive databases. In Proc. First International Conference on Expert Database Systems, pages 381-395. Benjamin/Cummings, 1986.

[Der83]

P. Deransart. Logical attribute grammars. In Proc. IFIP'83, pages 463-469, 1983.

[Der87a]

N. Dershowitz. Completion and its applications. Univ. of Illinois, 1987.

[Der87b]

N. Dershowitz. Termination of rewriting. J. Symbolic Computation, 3:69-116, 1987.

[Der91a]

N. Dershowitz. Canonical sets of horn clauses. In Proc. ICALP'91, pages 267-278. Springer LNCS 510, 1991.

[Der91b]

N. Dershowitz. Ordering-based strategies for horn clauses. In Proc. IJCAI-91, 1991.

[Der95]

N. Dershowitz. Goal solving as operational semantics. In Proc. of the 1995 International Logic Programming Symposium, pages 3-17. MIT Press, 1995.

[Des84]

T. Despeyroux. Executable specification of static semantics. Report no. 295, INRIA, 1984. Also appeared in Springer LNCS 173.

[Des91]

S. Dessloch. Handling integrity in a kbms architecture for workstation/server environments. In Proc. BTW'91, pages 89-108. Springer IFB 270, 1991.

[Deu91]

O. Deux. The o$_2$ system. Communications of the ACM, 34(10):34-48, 1991.

[DF87]

P. Deransart and G. Ferrand. An operational formal definition of prolog. In Proc. 4th IEEE Internat. Symposium on Logic Programming, pages 162-172, San Francisco, 1987.

[DF89a]

P. Deransart and G. Ferrand. A methodological view of logic programming with negation. Report no. 1011, INRIA, 1989.

[DF89b]

P. Deransart and G. Ferrand. Proof methods and declarative diagnosis in logic programming. Tutorial notes (ICLP'89), 1989.

[DFP86]

J. Darlington, A.J. Field, and H. Pull. The unification of functional and logic languages. In D. DeGroot and G. Lindstrom, editors, Logic Programming, Functions, Relations, and Equations, pages 37-70. Prentice Hall, 1986.

[DFPS89]

P. Deransart, P. Folkjaer, J.-F. Pique, and R.S. Scowen. Prolog: Draft for working draft 2.0. ISO Working group, 1989.

[DG89]

J. Darlington and Y. Guo. Narrowing and unification in functional programming - an evaluation mechanism for absolute set abstraction. In Proc. of the Conference on Rewriting Techniques and Applications, pages 92-108. Springer LNCS 355, 1989.

[DGB96]

S. Debray, D. Gudeman, and P. Bigot. Detection and optimization of suspension-free logic programs. Journal of Logic Programming, 29(1-3):171-194, 1996.

[DGKLM84]

V. Donzeau-Gouge, G. Kahn, B. Lang, and B. Melese. Document structure and modularity in mentor. In ACM, 1984.

[DGP92]

J. Darlington, Y. Guo, and H. Pull. A new perspective on integrating functional and logic languages. In Proc. Fifth Generation Computer Systems, pages 682-693, 1992.

[DH88]

R. Dietrich and F. Hagl. A polymorphic type system with subtypes for prolog. In Proc. ESOP 88, Nancy, pages 79-93. Springer LNCS 300, 1988.

[DHHM85]

M. Dahmen, J. Herr, K. Hinkelmann, and H. Morgenstern. Lisplog: Beiträge zur lisp/prolog-vereinheitlichung. Memo seki-85-10, Univ. Kaiserslautern, 1985.

[DHK95a]

G. Dowek, T. Hardin, and C. Kirchner. Higher-order unification via explicit substitutions. In Proc. LICS'95, pages 366-374, 1995.

[DHK95b]

G. Dowek, T. Hardin, and C. Kirchner. Higher order unification via explicit substitutions. Technical report no. 2709, INRIA Lorraine, 1995.

[DHKP96]

G. Dowek, T. Hardin, C. Kirchner, and F. Pfenning. Unification via explicit substitutions: The case of higher-order patterns. Technical report, INRIA Lorraine, 1996.

[Die93]

S. Diehl. How to design an abstract machine for compiling typed feature structures (draft). DFKI Saarbr{ücken, 1993.

[Dim92]

Y. Dimopoulos. Possibly a useful class of logic programs. MPI Informatik, 1992.

[DJ90a]

N. Dershowitz and J.-P. Jouannaud. Rewrite systems. In J. van Leeuwen, editor, Handbook of Theoretical Computer Science, Vol. B, pages 243-320. Elsevier, 1990.

[DJ90b]

D.J. Dougherty and P. Johann. An improved general e-unification method. In Proc. 10th Int. Conf. on Automated Deduction, pages 261-275. Springer LNCS 449, 1990.

[DJ91]

N. Dershowitz and J.-P. Jouannaud. Notations for rewriting. EATCS Bulletin, (43):162-172, 1991.

[DJBC92]

V. Dumortier, G. Janssens, M. Bruynooghe, and M. Codish. Freeness analysis in the presence of numerical constraints. Technical report cw 158, K.U. Leuven, 1992.

[DJL84]

P. Deransart, M. Jourdon, and B. Lorho. Speeding up circularity tests for attribute grammars. Acta Informatica, 21:375-391, 1984.

[Dju90]

I. Djurdjanovic. A fast garbage collection algorithm for wam-based prolog. In CSL'90. Springer LNCS, 1990.

[DKV95]

A. Degtyarev, Y. Koval, and A. Voronkov. Handling equality in logic programming via basic folding. Technical report no. 101, Uppsala University, 1995.

[DL86]

D. DeGroot and G. Lindstrom, editors. Logic Programming, Functions, Relations, and Equations. Prentice Hall, 1986.

[DL87]

N. Dershowitz and Y.-J. Lee. Deductive debugging. In Proc. 4th IEEE Internat. Symposium on Logic Programming, pages 298-306, San Francisco, 1987.

[DL93]

S.K. Debray and N.-W. Lin. Cost analysis of logic programs. ACM Transactions on Programming Languages and Systems, 15(5):826-875, 1993.

[DL97]

N. Dershowitz and N. Lindenstrauss. Abstract and-parallel machines. In Proc. EuroPar'97, pages 1221-1225. Springer LNCS 1300, 1997.

[DLH90]

S.K. Debray, N.-W. Lin, and M. Hermenegildo. Task granularity analysis in logic programs, 1990.

[DLP91]

W. Damm, F. Liu, and T. Peikenkamp. Introducing sharing into or-parallel implementations of logic programming. Univ. Oldenburg, 1991.

[DLP+96]

P. Devienne, P. Lebégue, A. Parrain, J.C. Routier, and J. Würtz. Smallest horn clause programs. Journal of Logic Programming, 27(3):227-267, 1996.

[DM79]

N. Dershowitz and Z. Manna. Proving termination with multiset orderings. Communications of the ACM, 22(8):465-476, 1979.

[DM82]

L. Damas and R. Milner. Principal type-schemes for functional programs. In Proc. 9th Annual Symposium on Principles of Programming Languages, pages 207-212, 1982.

[DM88]

S.K. Debray and P. Mishra. Denotational and operational semantics for prolog. Journal of Logic Programming (5), pages 61-91, 1988.

[DMC89]

B. Demoen, A. Mariën, and A. Callebaut. Indexing prolog clauses. In Proc. of the 1989 North American Conference on Logic Programming, pages 1001-1012. MIT Press, 1989.

[DMS90]

N. Dershowitz, S. Mitra, and G. Sivakumar. Equation solving in conditional ac-theories. In Proc. of the 2nd International Conference on Algebraic and Logic Programming, pages 283-297. Springer LNCS 463, 1990.

[DNTM88a]

W. Drabent, S. Nadjm-Tehrani, and J. Maluszynski. Algorithmic debugging with assertions. In Workshop on Meta-Programming in Logic Programming (Bristol), 1988.

[DNTM88b]

W. Drabent, S. Nadjm-Tehrani, and J. Maluszynski. The use of assertions in algrothmic debugging. In Proc. FGCS'88, pages 573-581, 1988.

[DO88]

N. Dershowitz and M. Okada. Conditional equational programming and the theory of conditional term rewriting. In Proc. Int. Conf. on Fifth Generation Computer Systems, pages 337-346, 1988.

[DO90]

N. Dershowitz and M. Okada. A rationale for conditional equational programming. Theoretical Computer Science, 75:111-138, 1990.

[Dom90]

E. Domenjoud. Solving systems of linear diophantine equations: An algebraic approach. CRIN & INRIA Lorraine, 1990.

[DOS87]

N. Dershowitz, M. Okada, and G. Sivakumar. Confluence of conditional rewrite systems. In Proc. 1st Int. Workshop on Conditional Term Rewriting Systems, pages 31-44. Springer LNCS 308, 1987.

[Dou89]

D.J. Dougherty. Adding algebraic rewriting to the untyped lambda caluclus. Wesleyan Univ., 1989.

[Dou90a]

D.J. Dougherty. Higher-order unification via combinators. Wesleyan University, 1990.

[Dou90b]

D.J. Dougherty. Some reduction properties of a lambda calculus with coproducts and recursive types. Wesleyan Univ., 1990.

[DP85]

N. Dershowitz and D.A. Plaisted. Logic programming cum applicative programming. In Proc. IEEE Internat. Symposium on Logic Programming, pages 54-66, Boston, 1985.

[DP88]

N. Dershowitz and D.A. Plaisted. Equational programming. In J.E. Hayes, D. Michie, and J. Richards, editors, Machine Intelligence 11, pages 21-56. Oxford Press, 1988.

[DPMP90]

A. Di Pierro, M. Martelli, and C. Palamidessi. Negation as instantiation: a new rule for the treatment of negation in loigc programming. Univ. Pisa, 1990.

[Dra96]

W. Drabent. Completeness of sldnf-resolution for nonfloundering queries. Journal of Logic Programming, 27(2):89-106, 1996.

[Dro88]

K. Drosten. Translating algebraic specifications to prolog programs: A comparative study. In Proc. First International Workshop on Algebraic and Logic Programming (Gaussig, G.D.R.), pages 137-146. Springer LNCS 343, 1988.

[DRW96]

S. Dawson, C.R. Ramakrishnan, and D.S. Warren. Practical program analysis using general purpose logic programming systems - a case study. In Proc. ACM SIGPLAN'96 Conference on Programming Language Design and Implementation, pages 117-126. ACM SIGPLAN Notices Vol. 31, No. 5, 1996.

[DS87]

N. Dershowitz and G. Sivakumar. Solving goals in equational languages. In Proc. 1st Int. Workshop on Conditional Term Rewriting Systems, pages 45-55. Springer LNCS 308, 1987.

[DSL95]

D. De Schreye and M. Leuschel. Program specialisation for logic programs. Slides presented at ILPS'95, 1995.

[DT88]

S. Danforth and C. Tomlinson. Type theories and object-oriented programming. ACM Computing Surveys, 20(1):29-72, 1988.

[Duc85]

M. Ducasse. Analysis of some prolog debugging tools. Technical report lp-5, ECRC, 1985.

[Duc87]

M. Ducasse. Opium - an extensible tracer for prolog. Technical report lp 14, ECRC, 1987.

[Duc91]

M. Ducasse. Abstract views of prolog executions in opium. In Proc. International Logic Programming Symposium, San Diego, 1991. MIT Press.

[Duc92]

M. Ducassé. A general trace query mechanism based on prolog. In Proc. of the 4th International Symposium on Programming Language Implementation and Logic Programming, pages 400-414. Springer LNCS 631, 1992.

[Dur94]

I. Durand. Bounded, strongly sequential and forward-branching term rewriting systems. J. Symbolic Computation, 18:319-352, 1994.

[DV96]

A. Degtyarev and A. Voronkov. Handling equality in logic programming via basic folding. In Proc. 5th International Workshop on Extensions of Logic Programming, pages 119-136. Springer LNAI 1050, 1996.

[DvH87]

M. Dincbas and P. van Hentenryck. Extended unification algorithms for the integration of functional programming into logic programming. Journal of Logic Programming (4), pages 199-227, 1987.

[DVHS+88]

M. Dincbas, P. Van Hentenryck, H. Simonis, A. Aggoun, T. Graf, and F. Berthier. The constraint logic programming language chip. In Proc. Int. Conf. on Fifth Generation Computer Systems, pages 693-702, 1988.

[DW86a]

S.K. Debray and D.S. Warren. Automatic mode inference for prolog programs. In Proc. Internat. Symposium on Logic Programming, pages 78-88, 1986.

[DW86b]

S.K. Debray and D.S. Warren. Detection and optimization of functional computations in prolog. In Proc. Third International Conference on Logic Programming (London), pages 490-504. Springer LNCS 225, 1986.

[DW88]

S.K. Debray and D.S. Warren. Automatic mode inference for logic programs. Journal of Logic Programming (5), pages 207-229, 1988.

[DW89a]

S.K. Das and M.H. Williams. A path finding method for constraint checking deductive databases. Data & Knowledge Engineering, 4:223-244, 1989.

[DW89b]

S.K. Debray and D.S. Warren. Functional computations in logic programs. ACM Transactions on Programming Languages and Systems, 11(3):451-481, 1989.

[Dyb91]

P. Dybjer. Inverse image analysis generalises strictness analysis. Information and Computation, 90:194-216, 1991.

[DZ88]

P.W. Dart and J. Zobel. Transforming typed logic programs into well-typed logic programs. Technical report 88/11, Univ. of Melbourne, 1988.

[Ech88]

R. Echahed. On completeness of narrowing strategies. In Proc. CAAP'88, pages 89-101. Springer LNCS 299, 1988.

[Ech92]

R. Echahed. Uniform narrowing strategies. In Proc. of the 3rd International Conference on Algebraic and Logic Programming, pages 259-275. Springer LNCS 632, 1992.

[Ede89]

E. Eder. Relative Complexities of First-Order Calculi. Habilitationsschrift, Univ. Dortmund, 1989.

[EHS93]

J.M. Edwards and B. Henderson-Sellers. A graphical notation for object-oriented analysis and design. Journal of Object-Oriented Programming, pages 53-74, 1993.

[Eis85a]

M. Eisenstadt. A powerful prolog trace package. In Advances in Artificial Intelligence, pages 149-158. Elsevier Science Publishers, 1985.

[Eis85b]

M. Eisenstadt. Retrospective zooming: a knowledge based tracing and debugging methodology for logic programming. In Proc. IJCAI'85, pages 717-719, 1985.

[EJ97a]

R. Echahed and J.C. Janodet. Admissible graph rewriting and narrowing. Technical report, IMAG-LSR, CNRS, Grenoble, 1997.

[EJ97b]

R. Echahed and J.C. Janodet. On constructor-based graph rewriting systems. Research report imag 985-i, IMAG-LSR, CNRS, Grenoble, 1997.

[EJ98]

R. Echahed and J.-C. Janodet. Admissible graph rewriting and narrowing. In Proc. Joint International Conference and Symposium on Logic Programming (JICSLP'98), pages 325-340, 1998.

[Elc89]

E.W. Elcock. Prolog: Subsumption of equality axioms by the homogeneous form. Journal of Logic Programming, pages 45-56, 1989.

[EM85]

H. Ehrig and B. Mahr. Fundamentals of Algebraic Specification 1: Equations and Initial Semantics, volume 6 of EATCS Monographs on Theoretical Computer Science. Springer, 1985.

[EM88]

C. Elkan and D. McAllester. Automated inductive reasoning about logic programs. In Proc. 5th Conference on Logic Programming & 5th Symposium on Logic Programming (Seattle), pages 876-892. MIT Press, 1988.

[ER98]

S. Escobar Román. Implementación de un lenguaje declarativo avanzado y su aplicación a la simulación del ecosistema de una cuenca hidrográfica (in spanish). Master's thesis, Facultad de Informática, Universidad Politécnica de Valencia, 1998.

[Erw98a]

M. Erwig. Abstract syntax and semantics of visual languages. Journal of Visual Languages and Computing, 9:461-483, 1998.

[Erw98b]

M. Erwig. Diets for fat sets. Journal of Functional Programming, 8(6):627-632, 1998.

[EU92]

A. Endres and J. Uhl. Objektorientierte software-entwicklung: Eine herausforderung für die projektführung. Informatik-Spektrum, 15(5):255-263, 1992.

[EW86]

H. Ehrig and H. Weber. Programming in the large with algebraic module specifications. In Proc. IFIP'86, pages 675-684, 1986.

[FA88]

D.A. Fuller and S. Abramsky. Mixed computation of prolog programs. New Generation Computing, 6:119-142, 1988.

[FA97]

T. Frühwirth and S. Abdennadher. Constraint-Programmierung. Springer, Berlin Heidelberg, 1997.

[Fag90]

F. Fages. A new fixpoint semantics for general logic programs compared with the well-founded and the stable model semantics. Report liens-90-11, LIENS, Paris, 1990.

[Fal87]

A. Falkner. Mode - ein modularer prolog-debugger. Technical report, TU Wien, 1987.

[Fa{\ss}95]

H. Fa\ssbender. A verified implementation of narrowing. In Proc. of PLILP'95. Springer LNCS (to appear), 1995.

[Fay79]

M.J. Fay. First-order unification in an equational theory. In Proc. 4th Workshop on Automated Deduction, pages 161-167, Austin (Texas), 1979. Academic Press.

[FB95]

T. Frühwirth and P. Brisset. High-level implementations of constraint handling rules. Technical report ecrc-tr-95-20, ECRC, 1995.

[FFNN]

K. Fuchi and K. Furukawa. The role of logic programming in the fifth generation computer project, NN.

[FGJM85]

K. Futatsugi, J.A. Goguen, J.-P. Jouannaud, and J. Meseguer. Principles of obj2. In Proc. of the 1985 ACM Symposium on Principles of Programming Languages, pages 52-66, 1985.

[FGRS86]

I. Foster, S. Gregory, G. Ringwood, and K. Satoh. A sequential implementation of parlog. In Proc. Third International Conference on Logic Programming (London), pages 149-156. Springer LNCS 225, 1986.

[FH88]

U. Furbach and S. Hölldobler. Fhcl - functions in horn clause logic. Report fki-86-88, TU M{ünchen, 1988.

[FH90]

U. Fraus and H. Hussmann. A narrowing-based theorem prover. Univ. Passau & TU M{ünchen, 1990.

[FH91]

U. Furbach and S. Hölldobler. Equations, order-sortedness, and inheritance in logic programming. In Advances in Logic Programming and Automated Reasoning, 1991.

[FH93]

T. Frühwirth and P. Hanschke. Terminological reasoning with constraint handling rules. Working paper ecrc-core-93-13, ECRC, 1993.

[FHJ91]

T. Franzen, S. Haridi, and S. Janson. An overview of the andorra kernel language. In Extensions of Logic Programming, pages 163-179. Springer LNCS 596, 1991.

[FHK+93]

T. Frühwirth, A. Herold, V. Küchenhoff, T. Le Provost, P. Lim, E. Monfroy, and M. Wallace. Constraint logic programming - an informal introduction. Technical report ecrc-93-5, ECRC, 1993.

[FHS88]

U. Furbach, S. Hölldobler, and J. Schreiber. Horn equality theories and paramodulation. Technical report 8801, {Universität} der Bundeswehr, {München}, 1988.

[Fit85]

M. Fitting. A deterministic prolog fixpoint semantics. Journal of Logic Programming, 2(2):111-118, 1985.

[Fit90]

M. Fitting. First-Order Logic and Automated Theorem Proving. Springer, 1990.

[Fit92]

M. Fitting. Many-valued logics and their use in logic programming. Advanced Tutorial at JICSLP'92, 1992.

[Fit93]

M. Fitting. Metric methods in the semantics of logic programming. Tutorial at ILPS'93, 1993.

[FJM+84]

C.N. Fischer, G.F. Johnson, J. Mauney, A. Pal, and D.L. Stock. The poe language-based editor project. In ACM, 1984.

[FL98]

M. Feeley and M. Larose. Compiling erlang to scheme. In Principles of Declarative Programming (Proc. Joint International Symposium PLILP/ALP'98), pages 300-317. Springer LNCS 1490, 1998.

[FLMP88]

M. Falaschi, G. Levi, M. Martelli, and C. Palamidessi. A new declarative semantics for logic languages. In Proc. 5th Conference on Logic Programming & 5th Symposium on Logic Programming (Seattle), pages 993-1005, 1988.

[FLO83]

S. Fortune, D. Leivant, and M. O'Donnell. The expressiveness of simple and second-order type structures. Journal of the ACM, 30(1):151-185, 1983.

[FLPM89]

M. Falaschi, G. Levi, C. Palamidessi, and M. Martelli. Declarative modelling of the operational behavior of logic languages. Theoretical Computer Science, 69:289-318, 1989.

[FM88]

Y.-C. Fuh and P. Mishra. Type inference with subtypes. In Proc. ESOP 88, Nancy, pages 94-114. Springer LNCS 300, 1988.

[FM90]

Y.-C. Fuh and P. Mishra. Type inference with subtypes. Theoretical Computer Science, 73:155-175, 1990.

[FPJ95]

S. Finne and S. Peyton Jones. Composing haggis. In Proc. of the Fifth Eurographics Workshop on Programming Paradigms for Computer Graphics. Springer, 1995.

[FR93]

G. File and S. Rossi. Static analysis of prolog with cut. In Proc. LPAR'93, pages 134-145. Springer LNAI 698, 1993.

[Fra91]

T. Franzen. Logical aspects of the andorra kernel language. Research report sics r91:12, SICS, 1991.

[Fre78]

E.C. Freuder. Synthesizing constraint expressions. Communications of the ACM, 21(11):959-966, 1978.

[Fre90]

P. Freedman. Programming with assert/1 and retract/1: A tale of 4 prologs. Rapport laas no. 90023, LAAS (Toulouse), 1990.

[Fri84]

L. Fribourg. Oriented equational clauses as a programming language. Journal of Logic Programming (1), pages 165-177, 1984.

[Fri85a]

L. Fribourg. Handling function definitions through innermost superposition and rewriting. In Proc. RTA'85, pages 325-344. Springer LNCS 202, 1985.

[Fri85b]

L. Fribourg. Slog: A logic programming language interpreter based on clausal superposition and rewriting. In Proc. IEEE Internat. Symposium on Logic Programming, pages 172-184, Boston, 1985.

[Fri86]

L. Fribourg. Slog 1.1 User's Manual, 1986.

[Fri88a]

L. Fribourg. Functional extensions to prolog: Are they needed?. In Proc. First International Workshop on Algebraic and Logic Programming (Gaussig, G.D.R.), pages 21-29. Springer LNCS 343, 1988.

[Fri88b]

L. Fribourg. Prolog with simplification. In K. Fuchi and M. Nivat, editors, Programming of Future Generation Computers, pages 161-183. Elsevier Science Publishers, 1988.

[Fri89]

L. Fribourg. Extracting logic programs from proofs that use extended prolog execution and induction. Report liens-89-12, LIENS Paris, 1989.

[FRTW88]

N. Foo, A. Rao, A. Taylor, and A. Walker. Deduced relevant types and constructive negation. In Proc. 5th Conference on Logic Programming & 5th Symposium on Logic Programming (Seattle), pages 126-139. MIT Press, 1988.

[Fr{ü88]

T.W. Frühwirth. Type inference by programs transformation and partial evaluation. In Int. Conf. on Computer Languages '88, 1988.

[Fr{ü89]

T.W. Frühwirth. Type inference by program transformation and partial evaluation. In H. Abramson and M.H. Rogers, editors, Meta-Progrmaming in Logic Programming. MIT Press, 1989.

[Fr{ü90]

T.W. Frühwirth. Polymorphic type checking with subtypes in prolog. In Proc. Int. Symposium on Design and Implementation of Symbolic Computation, pages 121-130. Springer LNCS 429, 1990.

[Fr{ü91]

T. Frühwirth. Introducing simplification rules: Towards a framework for extensible constraint logic programming. ECRC, 1991.

[Fr{ü92]

T. Frühwirth. Constraint simplification rules. Technical report ecrc-92-18, ECRC, 1992.

[Fr{ü93]

T. Frühwirth. Temporal reasoning with constraint handling rules. Working paper ecrc-core-93-8, ECRC, 1993.

[Fr{ü95]

T. Frühwirth. Constraint handling rules. In A. Podelski, editor, Constraint Programming: Basics and Trends, pages 90-107. Springer LNCS 910, 1995.

[FSS82]

R. Furuta, J. Scofield, and A. Shaw. Document formatting systems: Survey, concepts, and issues. ACM Computing Surveys, 14(3):417-472, 1982.

[FSVY91]

T. Frühwirth, E. Shapiro, M.Y. Vardi, and E. Yardeni. Logic programs as types for logic programs. In Proc. LICS'91, pages 300-309, 1991.

[Fuc84]

K. Fuchi. Logical derivation of a prolog interpreter. In Proc. Int. Conf. on Fifth Generation Computer Systems, pages 229-234. ICOT, 1984.

[Fuc98a]

D. Fuchs. Cooperation between top-down and bottom-up theorem provers by subgoal clause transfer. Seki report sr-98-01, Univ. Kaiserslautern, 1998.

[Fuc98b]

D. Fuchs. Requirement-based cooperative theorem proving. Seki report sr-98-02, Univ. Kaiserslautern, 1998.

[Fur92]

K. Furukawa. Logic programming as the integrator of the fifth generation computer systems project. Communications of the ACM, 35(3):82-92, 1992.

[FV92]

H. Fassbender and H. Vogler. A universal unification algorithm based on unification-driven leftmost outermost narrowing. Report 92-07, Univ. Ulm, 1992.

[Gal87]

J.H. Gallier. Logic for Computer Science - Foundations of Automatic Theorem Proving. Wiley, 1987.

[Gal90]

A. Galton. Logic for Information Technology. Wiley, 1990.

[Gal91a]

J. Gallier. Constructive logics. part i: A tutorial on proof systems and typed $λ$-calculi. Research report 8, DEC PRL, 1991.

[Gal91b]

J. Gallier. Constructive logics. part ii: Linear logic and proof nets. Research report 9, DEC PRL, 1991.

[Gal93]

J.P. Gallagher. Tutorial on specialisation of logic programs. In Proceedings of the ACM SIGPLAN Symposium on Partial Evaluation and Semantics Based Program Manipulation (PEPM'93), pages 88-98. ACM Press, 1993.

[Gal95]

E. Gallesio. STk Reference Manual. University of Nice, 1995.

[Gan83a]

H. Ganzinger. Increasing modularity and language-independency in automatically generated compilers. Report tum-i8306, TU M{ünchen, 1983.

[Gan83b]

H. Ganzinger. Parameterized specifications: Parameter passing and implementation with respect to observability. ACM TOPLAS, 5(3):318-354, 1983.

[Gan86]

H. Ganzinger. Programmiersprachen und ihre übersetzer. Skript zur Vorlesung im SS 1985, Univ. Dortmund, 1986.

[Gan87a]

H. Ganzinger. A completion procedure for conditional equations. In Proc. 1st Int. Workshop on Conditional Term Rewriting Systems, pages 62-83. Springer LNCS 308, 1987. Revised version in Ganzinger91.

[Gan87b]

H. Ganzinger. Ground term confluence in parametric conditional equational specifications. In Proc. STACS'87, pages 286-298. Springer LNCS 247, 1987.

[Gan88a]

H. Ganzinger. Completion with history-dependent complexities for generated equations. In Proc. Workshop on Abstract Data Types, pages 73-91. Springer LNCS 332, 1988.

[Gan88b]

H. Ganzinger. Order-sorted completion: The many-sorted way. Report 274, Univ. Dortmund, 1988.

[Gan91]

H. Ganzinger. A completion procedure for conditional equations. J. of Symb. Computation, 11:51-81, 1991.

[GB90]

J. Gallagher and M. Bruynooghe. The derivation of an algorithm for program specialisation. In Proc. Seventh International Conference on Logic Programming, pages 732-746. MIT Press, 1990.

[GB93]

M. Gollner and W. Barheine. Abschlu\ssbericht zur sprache kann (karlsruhe normal-narrowing). Internal report 3/93, Univ. Karlsruhe, 1993.

[GBNN]

J.A. Goguen and R. Burstall. Institutions: Abstract model theory for specification and programming. no comments, NN.

[GD94]

J. Goguen and R. Diaconescu. An oxford survey of order sorted algebra. In Mathematical Structures in Computer Science, 1994.

[GDK87]

G. Goos, R. Dietrich, and P. Kursawe. Prolog-arbeiten in karlsruhe. In 2. Int. GI-Kongress Wissensbasierte Systeme, pages 89-104. Springer Informatik Fachberichte 155, 1987.

[GDL95]

R. Giacobazzi, S.K. Debray, and G. Levi. Generalized semantics and abstract interpretation for constraint logic programs. Journal of Logic Programming, 25(3):191-247, 1995.

[GdlBH91]

M.J. Garc\'\ia de la Banda and M. Hermenegildo. Some considerations on the compile-time analysis of constraint logic programs. Technical report, Universidad Politecnica de Madrid, 1991.

[GdlBH92]

M.J. Garc\'\ia de la Banda and M. Hermenegildo. A practical approach to the global analysis of constraint logic programs. Technical report, Universidad Politecnica de Madrid, 1992.

[GdlBH93]

M. Garc\'\ia de la Banda and M. Hermenegildo. A practical approach to the global analysis of clp programs. In Proc. International Logic Programming Symposium, Vancouver, pages 437-455. MIT Press, 1993.

[GdlBMS95]

M. Garcia de la Banda, K. Marriott, and P. Stuckey. Efficient analysis of logic programs with dynamic scheduling. In Proc. of the International Logic Programming Symposium. MIT Press (to appear), 1995.

[Gel93]

M. Gelfond. Modelling actions in logic. Slides presented at ICLP'93, 1993.

[Gen96a]

D. Genius. Sequential implementation of parallel narrowing. In Proc. JICSLP'96 Workshop on Multi-Paradigm Logic Programming, pages 95-104. TU Berlin, Technical Report No. 96-28, 1996.

[Gen96b]

D. Genius. Vergleich und implementierung von narrowing-strategien in prolog. Master's thesis, RWTH Aachen, 1996.

[GFLCRA92]

A. Gavilanes Franco, F. Lucio Carrasco, and M. Rodriguez-Artalejo. Reasoning with higher-order partial functions. Technical report dia/92/13, Universidad Complutense Madrid, 1992.

[GG84]

H. Ganzinger and R. Giegerich. Attribute coupled grammars. In Proc. ACM SIGPLAN'84 Symposium on Compiler Construction, SIGPLAN Notices Vol. 19, No. 6, pages 157-170, 1984.

[GG87]

H. Ganzinger and R. Giegerich. A note on termination in combinations of heterogeneous term rewriting systems. In EATCS Bulletin, 1987.

[GG91]

R. Giegerich and S.L. Graham, editors. Code Generation - Concepts, Tools, Techniques. Dagstuhl-Seminar-Report 13, 1991.

[GG94]

P. Grogono and M. Gargul. A graph model for object oriented programming. ACM SIGPLAN Notices, 29(7):21-28, 1994.

[GGMW82]

H. Ganzinger, R. Giegerich, U. Moencke, and R. Wilhelm. A truly generative semantics-directed compiler generator. In ACM Symp. on Compiler Construction, 1982.

[GH84]

H. Ganzinger and M. Hanus. Modular logic programming of compilers. Report 189, Univ. Dortmund, 1984.

[GH85]

H. Ganzinger and M. Hanus. Modular logic programming of compilers. In Proc. IEEE Internat. Symposium on Logic Programming, pages 242-253, Boston, 1985.

[GH86]

A. Geser and H. Hussmann. Experiences with the rap system - a specification interpreter combining term rewriting and resolution. In Proc. of ESOP 86, pages 339-350. Springer LNCS 213, 1986.

[GH88]

A. Geser and H. Hussmann. The rap system from the user's point of view. Mip-intern 02/88, Univ. Passau, 1988.

[GHJV93]

E. Gamma, R. Helm, R. Johnson, and J. Vlissides. Design patterns: Abstraction and reuse of object-oriented design. In Proc. ECOOP'93, pages 406-431. Springer LNCS 707, 1993.

[GHM87]

A. Geser, H. Hussmann, and A. Mück. A compiler for a class of conditional term rewriting systems. In Proc. 1st Int. Workshop on Conditional Term Rewriting Systems, pages 84-90. Springer LNCS 308, 1987.

[GI88]

J.H. Gallier and T. Isakowitz. Rewriting in order-sorted equational logic. In Proc. 5th Conference on Logic Programming & 5th Symposium on Logic Programming (Seattle), pages 280-294. MIT Press, 1988.

[Gib91]

J. Gibert. Declarative Symbolic Computations. PhD thesis, Univ. of Melbourne, 1991. Published as Technical Report 91/31.

[Gie79]

R. Giegerich. Introduction to the compiler generation system mug2. Report tum-info-7913, TU M{ünchen, 1979.

[Gie90]

R. Giegerich. Code selection by inversion of order-sorted derivors. Theoretical Computer Science, 73:177-211, 1990.

[Gir87]

J.-Y. Girard. Linear logic. Theoretical Computer Science 50, pages 1-102, 1987.

[GJ93]

G. Gupta and B. Jayaraman. Analysis of or-parallel execution models. ACM Transactions on Programming Languages and Systems, 15(4):659-680, 1993.

[GKP96]

G.A. Geist, J.A. Kohl, and P.M. Papadopoulos. Pvm and mpi: a comparison of features. Calculateures Paralleles, 8(2), 1996.

[GL89]

U. Griefahn and S. Lüttringhaus. Integrity constraint checking for deductive databases. Technical report 305, Univ. Dortmund, 1989.

[GL90]

U. Griefahn and S. Lüttringhaus. Top-down integrity constraint checking for deductive databases. In Proc. Seventh International Conference on Logic Programming, pages 130-144. MIT Press, 1990.

[GLLO85]

J. Gabriel, T. Lindholm, E.L. Lusk, and R.A. Overbeek. A tutorial on the warren abstract machine for computational logic. Technical report anl-84-84, Argonne National Laboratory, Argonne (Illinois), 1985.

[GLMP91]

E. Giovannetti, G. Levi, C. Moiso, and C. Palamidessi. Kernel leaf: A logic plus functional language. Journal of Computer and System Sciences, 42(2):139-185, 1991.

[GM82]

J.A. Goguen and J. Meseguer. Completeness of many-sorted equational logic. SIGPLAN Notices, 17(1), 1982.

[GM84]

J.A. Goguen and J. Meseguer. Completeness of many-sorted equational logic. Report no. csli-84-15, Stanford University, 1984.

[GM85]

J.A. Goguen and J. Meseguer. Order-sorted algebra i: Partial and overloaded operators, errors and inheritance. Draft, 1985.

[GM86a]

E. Giovannetti and C. Moiso. A completeness result for e-unification algorithms based on conditional narrowing. In Proc. Workshop on Foundations of Logic and Functional Programming, pages 157-167. Springer LNCS 306, 1986.

[GM86b]

J.A. Goguen and J. Meseguer. Eqlog: Equality, types, and generic modules for logic programming. In D. DeGroot and G. Lindstrom, editors, Logic Programming, Functions, Relations, and Equations, pages 295-363. Prentice Hall, 1986.

[GM87a]

E. Giovannetti and C. Moiso. Notes on the elimination of conditions. In Proc. CTRS'87, pages 91-97. Springer LNCS 308, 1987.

[GM87b]

J.A. Goguen and J. Meseguer. Models and equality for logical programming. In Proc. of the TAPSOFT '87, pages 1-22. Springer LNCS 250, 1987.

[GM87c]

Y. Gurevich and J.M. Morris. Algebraic operational semantics and modula-2. In Proc. 1st Workshop on Computer Science Logic, pages 81-101. Springer LNCS 329, 1987.

[GM90]

Y. Gurevich and L.S. Moss. Algebraic operational semantics and occam. In Proc. 3rd Computer Science Logic Workshop, pages 176-192. Springer LNCS 440, 1990.

[GM92]

J. Grant and J. Minker. The impact of logic programming on databases. Communications of the ACM, 35(3):66-81, 1992.

[GM93]

R. Godin and H. Mili. Building and maintaining analysis-level class hierarchies using galois lattices. In Proc. OOPSLA'93, pages 394-410. ACM SIGPLAN Notices Vol. 28, No. 10, 1993.

[GMHGLFRA96a]

J.C. Gonzáles-Moreno, M.T. Hortalá-González, F.J. López-Fraguas, and M. Rodr\'\iguez-Artalejo. A rewriting logic for declarative programming. In Proc. ESOP'96, pages 156-172. Springer LNCS 1058, 1996.

[GMHGLFRA96b]

J.C. Gonzales-Moreno, T. Hortala-Gonzalez, F. Lopez-Fraguas, and M. Rodriguez-Artalejo. A rewriting logic for declarative programming. In To appear in ESOP'96, 1996.

[GMHGLFRA99]

J.C. González-Moreno, M.T. Hortalá-González, F.J. López-Fraguas, and M. Rodr\'\iguez-Artalejo. An approach to declarative programming based on a rewriting logic. Journal of Logic Programming, 40:47-87, 1999.

[GMHGRA90]

J.C. Gonzalez-Moreno, M.T. Hortala-Gonzalez, and M. Rodriguez-Artalejo. A functional logic language with higher order logic variables. Technical report, Univ. Comp. Madrid, 1990.

[GMHGRA91]

J.C. Gonzalez-Moreno, M.T. Hortala-Gonzalez, and M. Rodriguez-Artalejo. Denotational versus declarative semantics for functional programming. In Proc. CSL'91, 1991.

[GMHGRA92a]

J.C. González-Moreno, M.T. Hortalá-González, and M. Rodr\'\iguez-Artalejo. On the completeness of narrowing as the operational semantics of functional logic programming. Technical report dia 92/14, Universidad Complutense Madrid, 1992. To appear in Proc. CSL'92, Springer LNCS.

[GMHGRA92b]

J.C. González-Moreno, M.T. Hortalá-González, and M. Rodr\'\iguez-Artalejo. On the completeness of narrowing as the operational semantics of functional logic programming. In Proc.\ CSL'92, pages 216-230. Springer LNCS 702, 1992.

[GMHGRA97]

J.C. González-Moreno, M.T. Hortalá-González, and M. Rodr\'\iguez-Artalejo. A higher order rewriting logic for functional logic programming. In Proc.\ of the Fourteenth International Conference on Logic Programming (ICLP'97), pages 153-167. MIT Press, 1997.

[GMP86]

J. Gee, S.W. Melvin, and Y.N. Patt. The implementation of prolog via vax 8600 microcode. In Proc. 19th Annual Workshop on Microprogramming, pages 68-74, New York, 1986.

[GN87]

M.R. Genesereth and N.J. Nilsson. Logical Foundations of Artificial Intelligence. Morgan Kaufmann Publishers, 1987.

[G{öb83]

R. Göbel. A completion procedure for globally finite term rewriting systems. Memo seki-83-11, Univ. Kaiserslautern, 1983.

[Gog90a]

J.A. Goguen. An algebraic approach to refinement. Draft, 1990.

[Gog90b]

J.A. Goguen. Semantic specifications for the rewrite rule machine. In Concurrency: Theory, Language and Architecture. Springer LNCS, 1990.

[Gog90c]

J.A. Goguen. Types as theories. In Proc. Symp. on General Topology and Applications. Oxford University Press, 1990.

[Gol81a]

C.F. Goldfarb. A generalized approach to document markup. In Proc. ACM SIGPLAN SIGOA Symposium on Text Manipulation, Portland/Oregon, pages 68-73. SIGOA Newsletter, Vol. 2, No. 1+2, 1981.

[Gol81b]

W. Goldfarb. The undecidability of the second-order unification problem. Theoretical Computer Science 13, pages 225-230, 1981.

[Gol92a]

M. Gollner, editor. The Implementation of Logical-Functional Languages. Univ. Karlsruhe, Interner Bericht 10/92, 1992.

[Gol92b]

H.-J. Goltz. A constructive type system based on data terms. In Logics in AI, pages 279-303. Springer LNAI 633, 1992.

[Gol93]

M. Gollner. A simple algebraic languages with tests and ordered sorts (salto): Language definition & operational semantics. Internal report 7/93, Univ. Karlsruhe, 1993.

[Gol96]

M. Gollner. Eine abstrakte Maschine für das logisch-funktionale Programmieren. PhD thesis, Universit{ät Karlsruhe, 1996.

[Gom92]

C.K. Gomard. A self-applicable partial evaluator for the lambda-calculus: Correctness and pragmatics. ACM Transactions on Programming Languages and Systems, 14(2):147-172, 1992.

[Gor81]

H.T. Gordon. What forth is?. Dr. Dobb's Journal, 1981.

[GP91]

Y. Guo and H. Pull. Falcon: Functional and logic language with constraints (language definition). Imperial College, London, 1991.

[GR86]

J.H. Gallier and S. Raatz. Sld-resolution methods for horn clauses with equality based on e-unification. In Proc. IEEE Internat. Symposium on Logic Programming, pages 168-179, Salt Lake City, 1986.

[GR89]

J.H. Gallier and S. Raatz. Extending sld-resolution to equational horn clauses using e-unification. Journal of Logic Programming (6), pages 3-43, 1989.

[Gra91]

I. Graham. Object Oriented Methods. Addison-Wesley, 1991.

[Gre69]

C.C. Green. The Application of Theorem Proving Question-Answering Systems. PhD thesis, Stanford University, 1969.

[Gr{ü90]

T. Grünler. Spezifikationen höherer ordnung. Report mip-9012, Univ. Passau, 1990.

[GS89]

J.H. Gallier and W. Snyder. Complete sets of transformations for general e-unification. Theoretical Computer Science, 67:203-260, 1989.

[GS90]

H. Ganzinger and R. Schäfers. System support for modular order-sorted horn clause specifications. In Proc. 12th Int. Conference on Software Engineering (Nice), pages 150-163, 1990.

[GS92]

M. Gollner and C. Scharnhorst. Integration logischer und funktionale sprachkonzepte mit dem normalisierenden narrowing-system kann. Univ. Karlsruhe, 1992.

[GSC96]

G. Gupta and V. Santos Costa. Cuts and side-effects in an and-or parallel prolog. Journal of Logic Programming, 27(1):45-71, 1996.

[GTC+90]

S. Gibbs, D. Tsichritzis, E. Casais, O. Nierstrasz, and X. Pintado. Class management for software communities. Communications of the ACM, 33(9):90-103, 1990.

[GTW78]

J.A. Goguen, J.W. Thatcher, and E.G. Wagner. An initial algebra approach to the specification, correctness, and implementation of abstract data types. In R. Yeh, editor, Current Trends in Programming Methodology, volume 4, pages 80-149. Prentice Hall, Englewood Cliffs NJ, 1978.

[Gup93]

G. Gupta. Parallel logic programming. Slides presented at ICLP'93, 1993.

[Gup94]

G. Gupta. Multiprocessor Execution of Logic Programs. Kluwer Academic Publishers, 1994.

[GW78]

R. Giegerich and R. Wilhelm. Implementierbarkeit attributierter grammatiken. TU M{ünchen, 1978.

[GW82]

H. Ganzinger and W. Willmertinger. Ein textformatierer für ein mikroprozessorsystem. Internal report tum-info-05, TU M{ünchen, 1982.

[GW83]

H. Ganzinger and W. Willmertinger. Foam: A two-level approach to text formatting on a micro computer system. Technical report, TU M{ünchen, 1983.

[GW92]

H. Ganzinger and U. Waldmann. Termination proofs of well-moded logic programs via conditional rewrite systems. to appear in CTRS'92, 1992.

[GWB91]

R.P. Gabriel, J.L. White, and D.G. Bobrow. Clos: Integrating object-oriented and functional programming. Communications of the ACM, 34(9):28-38, 1991.

[GZ86]

Y. Gang and X. Zhiliang. An efficient type system for prolog. In Proc. IFIP '86, pages 355-359. North-Holland, 1986.

[HAK+99]

M. Hanus, S. Antoy, J. Koj, R. Sadre, and F. Steiner. Pacs: The portland aachen curry system. Available at \verb+http://www-i2.informatik.rwth-aachen.de/~hanus/pacs/+, 1999.

[HAK+00a]

M. Hanus, S. Antoy, J. Koj, P. Niederau, R. Sadre, and F. Steiner. Pacs: The portland aachen curry system. Available at \verb+http://www-i2.informatik.rwth-aachen.de/~hanus/pacs/+, 2000.

[HAK+00b]

M. Hanus, S. Antoy, J. Koj, P. Niederau, R. Sadre, and F. Steiner. Pakcs: The portland aachen kiel curry system. Available at \verb+http://www.informatik.uni-kiel.de/~pakcs/+, 2000.

[Han83]

M. Hanus. Prinzipien zur spezifikation und generierung von textformatierern. Master's thesis, FB Informatik, Univ. Dortmund, 1983.

[Han86]

M. Hanus. Formatierer für text und graphik und ihre implementierung mit smalltalk-80. In Graphik in Dokumenten, pages 78-89. Springer Informatik-Fachberichte 119, 1986.

[Han87a]

W. Hankley. Feature analysis of turbo prolog. SIGPLAN Notices, 22(3):111-118, 1987.

[Han87b]

M. Hanus. Problemlösen mit Prolog. Teubner, Stuttgart, 1987. 2. {überarbeitete und erweiterte Auflage.

[Han88a]

M. Hanus. Formal specification of a prolog compiler. In Proc. of the Workshop on Programming Language Implementation and Logic Programming, pages 273-282, Orléans, 1988. Springer LNCS 348.

[Han88b]

M. Hanus. Horn clause programs with polymorphic types. Technical report 248, FB Informatik, Univ. Dortmund, 1988.

[Han88c]

M. Hanus. Horn Clause Specifications with Polymorphic Types. Dissertation, FB Informatik, Univ. Dortmund, 1988.

[Han89a]

M. Hanus. Horn clause programs with polymorphic types: Semantics and resolution. In Proc. of the TAPSOFT '89, pages 225-240. Springer LNCS 352, 1989. Extended version to appear in Theoretical Computer Science.

[Han89b]

M. Hanus. Horn clause programs with polymorphic types: Semantics and resolution. In Proc. of the TAPSOFT '89, pages 225-240. Springer LNCS 352, 1989. Extended version in Hanus91TCS.

[Han89c]

M. Hanus. Implementierung logischer programmiersprachen. Skript zu einer Spezialvorlesung (Univ. Dortmund), 1989.

[Han89d]

M. Hanus. Logic programming with type specifications. Technical report 321, FB Informatik, Univ. Dortmund, 1989.

[Han89e]

M. Hanus. Polymorphic higher-order programming in prolog. In Proc. Sixth International Conference on Logic Programming (Lisboa), pages 382-397. MIT Press, 1989.

[Han90a]

Werner Hans. Entwurf einer abstrakten maschine für eine und-parallele implementierung der funktionalen logik-programmiersprache babel auf einem lose gekoppelten multicomputer-system. Diplomarbeit, RWTH Aachen, 1990.

[Han90b]

M. Hanus. Compiling logic programs with equality. In Proc. of the 2nd Int. Workshop on Programming Language Implementation and Logic Programming, pages 387-401. Springer LNCS 456, 1990.

[Han90c]

M. Hanus. A functional and logic language with polymorphic types. In Proc. Int. Symposium on Design and Implementation of Symbolic Computation Systems, pages 215-224. Springer LNCS 429, 1990.

[Han90d]

M. Hanus. Logic programs with equational type specifications. In Proc. of the 2nd International Conference on Algebraic and Logic Programming, pages 70-85. Springer LNCS 463, 1990.

[Han91a]

J.L. Han. Preventing infinite looping in prolog. In IEEE Intl. Conference on Tools for AI, San Jose (CA), 1991.

[Han91b]

M. Hanus. Efficient implementation of narrowing and rewriting. In Proc.\ Int.\ Workshop on Processing Declarative Knowledge, pages 344-365. Springer LNAI 567, 1991.

[Han91c]

M. Hanus. Horn clause programs with polymorphic types: Semantics and resolution. Theoretical Computer Science, 89:63-106, 1991.

[Han91d]

M. Hanus. Parametric order-sorted types in logic programming. Technical report 377, FB Informatik, Univ. Dortmund, 1991.

[Han91e]

M. Hanus. Parametric order-sorted types in logic programming. In Proc. of the TAPSOFT '91, pages 181-200. Springer LNCS 494, 1991.

[Han91f]

M. Hanus. Unification with polymorphic type constraints. Technical report, FB Informatik, Univ. Dortmund (to appear), 1991.

[Han92a]

M. Hanus. An abstract interpretation algorithm for residuating logic programs. Technical report mpi-i-92-217, Max-Planck-Institut f{ür Informatik, Saarbr{ücken, 1992.

[Han92b]

M. Hanus. Analysis of nonlinear constraints in clp($\cal r$). Technical report mpi-i-92-251, Max-Planck-Institut f{ür Informatik, Saarbr{ücken, 1992.

[Han92c]

M. Hanus. Improving control of logic programs by using functional logic languages. In Proc. of the 4th International Symposium on Programming Language Implementation and Logic Programming, pages 1-23. Springer LNCS 631, 1992.

[Han92d]

M. Hanus. Incremental rewriting in narrowing derivations. In Proc. of the 3rd International Conference on Algebraic and Logic Programming, pages 228-243. Springer LNCS 632, 1992.

[Han92e]

M. Hanus. Logic programming with type specifications. In F. Pfenning, editor, Types in Logic Programming, chapter 3, pages 91-140. MIT Press, 1992.

[Han92f]

M. Hanus. On the completeness of residuation. In Proc. of the 1992 Joint International Conference and Symposium on Logic Programming, pages 192-206. MIT Press, 1992.

[Han92g]

M. Hanus. Operational semantics of equational logic languages. 9th Workshop on Abstract Data Types - 4th Compass Workshop, Caldes de Malavella (Spain), 1992.

[Han93a]

M. Hanus. Analysis of nonlinear constraints in clp($\cal r$). In Proc. Tenth International Conference on Logic Programming, pages 83-99. MIT Press, 1993.

[Han93b]

M. Hanus. Lazy unification with inductive simplification. Technical report mpi-i-93-215, Max-Planck-Institut f{ür Informatik, Saarbr{ücken, 1993.

[Han93c]

M. Hanus. Towards the global optimization of functional logic programs. In Proc.\ of the Workshop on Global Compilation, International Logic Programming Symposium, Vancouver, 1993.

[Han94a]

M. Hanus. Combining lazy narrowing and simplification. In Proc. of the 6th International Symposium on Programming Language Implementation and Logic Programming, pages 370-384. Springer LNCS 844, 1994.

[Han94b]

M. Hanus. The integration of functions into logic programming: A survey. Technical report mpi-i-94-201, Max-Planck-Institut f{ür Informatik, Saarbr{ücken, 1994.

[Han94c]

M. Hanus. The integration of functions into logic programming: From theory to practice. Journal of Logic Programming, 19&20:583-628, 1994.

[Han94d]

M. Hanus. Lazy unification with simplification. In Proc.\ 5th European Symposium on Programming, pages 272-286. Springer LNCS 788, 1994.

[Han94e]

M. Hanus. On extra variables in (equational) logic programming. Technical report mpi-i-94-246, Max-Planck-Institut f{ür Informatik, Saarbr{ücken, 1994.

[Han94f]

M. Hanus. Towards the global optimization of functional logic programs. In Proc.\ 5th International Conference on Compiler Construction, pages 68-82. Springer LNCS 786, 1994.

[Han95a]

M. Hanus. Analysis of residuating logic programs. Journal of Logic Programming, 24(3):161-199, 1995.

[Han95b]

M. Hanus. Compile-time analysis of nonlinear constraints in clp($\cal r$). New Generation Computing, 13(2):155-186, 1995.

[Han95c]

M. Hanus. Efficient translation of lazy functional logic programs into prolog. In Proc.\ Fifth International Workshop on Logic Program Synthesis and Transformation, pages 252-266. Springer LNCS 1048, 1995.

[Han95d]

M. Hanus. On extra variables in (equational) logic programming. In Proc. International Conference on Logic Programming, pages 665-679. MIT Press, 1995.

[Han96a]

M. Hanus. Integration of declarative paradigms: Benefits and challenges. ACM Computing Surveys, 28A(4), 1996. Also in ACM SIGPLAN Notices, Vol. 32, No. 1, 1997, 77-79.

[Han96b]

M. Hanus. A simple operational model for concurrent functional logic programming. In Proc. JICSLP'96 Workshop on Multi-Paradigm Logic Programming, pages 83-94. TU Berlin, Technical Report No. 96-28, 1996.

[Han97a]

M. Hanus. Lazy narrowing with simplification. Computer Languages, 23(2-4):61-85, 1997.

[Han97b]

M. Hanus. Teaching functional and logic programming with a single computation model. In Proc.\ Ninth International Symposium on Programming Languages, Implementations, Logics, and Programs (PLILP'97), pages 335-350. Springer LNCS 1292, 1997.

[Han97c]

M. Hanus. A unified computation model for functional and logic programming. In Proc.\ of the 24th ACM Symposium on Principles of Programming Languages (Paris), pages 80-93, 1997.

[Han99]

M. Hanus. Distributed programming in a multi-paradigm declarative language. In Proc.\ of the International Conference on Principles and Practice of Declarative Programming (PPDP'99), pages 376-395. Springer LNCS 1702, 1999.

[Han00a]

M. Hanus. A functional logic programming approach to graphical user interfaces. In International Workshop on Practical Aspects of Declarative Languages (PADL'00), pages 47-62. Springer LNCS 1753, 2000.

[Han00b]

M. Hanus. Server side web scripting in curry. In Workshop on (Constraint) Logic Programming and Software Engineering (LPSE2000), 2000.

[Han01]

M. Hanus. High-level server side web scripting in curry. In Proc.\ of the Third International Symposium on Practical Aspects of Declarative Languages (PADL'01), pages 76-92. Springer LNCS 1990, 2001.

[Har86]

R. Harper. Introduction to standard ml. Lfcs report series ecs-lfcs-86-14, University of Edinburgh, 1986.

[Har89]

J. Harland. A kripke-like model for negation as failure. In Proc. of the 1989 North American Conference on Logic Programming, pages 626-642. MIT Press, 1989.

[Har90]

S. Haridi. A logic programming language based on the andorra model. New Generation Computing, 7:109-125, 1990.

[Har91]

J. Harland. Success and failure for hereditary harrop formulae. Technical report 91/17, Univ. of Melbourne, 1991.

[Har94]

J. Hartmanis. About the nature of computer science. EATCS Bulletin, (53):170-190, 1994.

[Has95]

R. Hasegawa. Model generation theorem provers and their applications. Slides presented at ICLP'95, 1995.

[HB88]

S. Haridi and P. Brand. Andorra prolog: An integration of prolog and committed choice languages. In Proc. Int. Conf. on Fifth Generation Computer Systems, pages 745-754, 1988.

[HBB+91]

C. Hintermeier, C. Brzoska, A. Biere, I. Varsek, T. Weinstein, and A. Werner. Lopster: Sprachdefinition. Internal report 18/91, Univ. Karlsruhe, 1991.

[HE94]

Yong-Fei Han and D.J. Evans. Parallel inference algorithms for the connection method on systolic arrays. Intern. J. Computer Math., 1994.

[He97]

M. Hanus (ed.). Curry: An integrated functional logic language. Available at \verb+http://www-i2.informatik.rwth-aachen.de/~hanus/curry+, 1997.

[He98]

M. Hanus (ed.). Curry: An integrated functional logic language. Available at \verb+http://www-i2.informatik.rwth-aachen.de/~hanus/curry+, 1998.

[He99]

M. Hanus (ed.). Curry: An integrated functional logic language (vers.\ 0.5). Available at \verb+http://www-i2.informatik.rwth-aachen.de/~hanus/curry+, 1999.

[He00]

M. Hanus (ed.). Curry: An integrated functional logic language (vers.\ 0.7). Available at \verb+http://www-i2.informatik.rwth-aachen.de/~hanus/curry+, 2000.

[Hen90a]

A.V. Hense. Denotational semantics of an object oriented programming language with explicit wrappers. Technical report a 11/90, Univ. des Saarlandes, 1990.

[Hen90b]

A.V. Hense. Polymorphic type inference for a simple object oriented programming language with state. Technical report a 20/90, Univ. des Saarlandes, 1990.

[Hen90c]

A.V. Hense. Wrapper semantics of an object oriented programming language with state. Technical report a 14/90, Univ. des Saarlandes, 1990.

[Hen93]

F. Henglein. Type inference with polymorphic recursion. ACM Transactions on Programming Languages and Systems, 15(2):253-289, 1993.

[Her86]

A. Herold. Narrowing techniques applied to idempotent unification. Seki-report sr 86-16, Univ. Kaiserslautern, 1986.

[Her87]

M. Hermenegildo. Relating goal scheduling, precedence, and memory management in and-parallel execution of logic programs. In Proc. Fourth International Conference on Logic Programming (Melbourne), pages 556-576. MIT Press, 1987.

[Her89]

M. Hermenegildo. High-performance prolog implementation: The wam and beyond. Tutorial notes at ICLP'89 (Lisboa), 1989.

[Her92]

M. Hermenegildo. Abstract interpretation and its applications. Advanced Tutorial at JICSLP'92, 1992.

[Heu87]

T. Heuillard. Compiling conditional rewriting systems. In Proc. 1st Int. Workshop on Conditional Term Rewriting Systems, pages 111-128. Springer LNCS 308, 1987.

[HF92]

P. Hudak and J.H. Fasel. A gentle introduction to haskell. SIGPLAN Notices, 27(5), 1992.

[HF96]

P.H. Hartel and M. Feeley. Benchmarking implementations of functional languages with 'pseudoknot', a float-intensive benchmark. Journal of Functional Programming, 6(4):621-655, 1996.

[HFN97]

A. Hamfelt and J. Fischer Nilsson. Towards a logic programming methodology based on higher-order predicates. New Generation Computing, 15(4):421-448, 1997.

[HG90]

M.V. Hermenegildo and K.J. Greene. &-prolog and its performance: Exploiting independent and-parallelism. In Proc. Seventh International Conference on Logic Programming, 1990.

[HG91]

M.V. Hermenegildo and K.J. Greene. The &-prolog system: Exploiting independent and-parallelism transparently. To appear in New Generation Computing, 1991.

[HGU01]

T. Hortalá-González and E. Ullán. An abstract machine based system for a lazy narrowing caclulus. In Proc.\ of the 5th International Symposium on Functional and Logic Programming (FLOPS 2001), pages 216-232. Springer LNCS 2024, 2001.

[HH82]

G. Huet and J.-M. Hullot. Proofs by induction of equational theories with constructors. Journal of Computer and System Sciences 25, pages 239-266, 1982.

[HHG90]

R. Helm, I.M. Holland, and D. Gangopadhyay. Contracts: Specifying behavorial composition in object-oriented systems. In Proc. ECOOP/OOPSLA'90, pages 169-180. SIGPLAN Notices Vol. 25, No. 10, 1990.

[HHN01]

M. Hanus, F. Huch, and P. Niederau. An object-oriented extension of the declarative multi-paradigm language curry. In Proc.\ of the 12th International Workshop on Implementation of Functional Languages (IFL 2000), pages 89-106. Springer LNCS 2011, 2001.

[HHP93]

R. Harper, F. Honsell, and G. Plotkin. A framework for defining logics. Journal of the ACM, 40(1):143-184, 1993.

[HIA+81]

M. Hammer, R. Ilson, T. Anderson, E. Gilbert, M. Good, B. Niamir, L. Rosenstein, and S. Schoichet. The implementation of etude, an integrated and interactive document production system. In Proc. ACM SIGPLAN SIGOA Symposium on Text Manipulation, Portland/Oregon, pages 137-146. SIGOA Newsletter, Vol. 2, No. 1+2, 1981.

[Hic91]

T.J. Hickey. Higher-order constraint logic programming. Technical Report, Brandeis Univ., 1991.

[Hil93]

P.M. Hill. The completion of typed logic programs and sldnf-resolution. In Proc. LPAR'93, pages 182-193. Springer LNAI 698, 1993.

[Hin92]

R. Hinze. Einführung in die funktionale Programmierung mit Miranda. Teubner, Stuttgart, 1992.

[Hin94]

C. Hintermeier. How to transform canonical conditional trs's into equivalent canonical trs's. In To appear in Proc. CTRS'94, 1994.

[HJ89]

N. Heintze and J. Jaffar. A finite presentation theorem for approximating logic programs. Summary in Proc. 17th POPL, 1989.

[HJ90a]

S. Haridi and S. Janson. Kernel andorra prolog and its computation model. In Proc. International Conference on Logic Programming, pages 31-46. MIT Press, 1990.

[HJ90b]

N. Heintze and J. Jaffar. A finite presentation theorem for approximating logic programs. In Proc. 17th POPL, pages 197-209, 1990.

[HJ92]

M. Hanus and B. Josephs. A debugging model for functional logic programs. In Proc. of the 4th Workshop on Logic Programming Environments (Washington, D.C., November 1992), pages 35-41. Technical Report TR92-143, Case Western Reserve University, 1992.

[HJ93]

M. Hanus and B. Josephs. A debugging model for functional logic programs. In Proc. of the 5th International Symposium on Programming Language Implementation and Logic Programming, pages 28-43. Springer LNCS 714, 1993.

[HJ94]

P. Hudak and M.P. Jones. Haskell vs. ada vs. c++ vs. awk vs.... an experiment in software prototyping productivity. Technical report, Yale University, 1994.

[HJM+91]

N. Heintze, J. Jaffar, S. Michaylov, P. Stuckey, and R. Yap. The CLP($\cal R$) Programmer's Manual, Version 1.1. IBM Thomas J. Watson Research Center, Yorktown Heights, 1991.

[HJP92]

S. Haridi, S. Janson, and C. Palamidessi. Structural operational semantics for akl. Journal of Future Generation Computer Systems, 8:409-421, 1992.

[HK87]

K. Horiuchi and T. Kanamori. Polymorphic type inference in prolog by abstract interpretation. In Logic Programming '87 (Tokyo), pages 195-214. Springer LNCS 315, 1987.

[HKK93]

C. Hintermeier, C. Kirchner, and H. Kirchner. Dynamically-typed computations for order-sorted equational presentations. Research report crin 93-r-309, CRIN, Nancy, 1993.

[HKL91]

G. Hogen, A. Kindler, and R. Loogen. Automatic parallelization of lazy functional programs. Report 91-20, RWTH Aachen, 1991.

[HKLRNN]

J. Hsiang, H. Kirchner, P. Lescanne, and M. Rusinowitch. The term rewriting approach to automated theorem proving. LORIA-CRIN, NN.

[HKMN95]

M. Hanus, H. Kuchen, and J.J. Moreno-Navarro. Curry: A truly functional logic language. In Proc. ILPS'95 Workshop on Visions for the Future of Logic Programming, 1995.

[HKW93a]

W. Hans, H. Kuchen, and S. Winkler. Full indexing for lazy narrowing. RWTH Aachen, submitted for publication, 1993.

[HKW93b]

W. Hans, H. Kuchen, and S. Winkler. Full indexing for lazy narrowing. Technical report 93-18, RWTH Aachen, 1993.

[HL79]

G. Huet and J.-J. Levy. Call by need computations in non-ambiguous linear term rewriting systems. Rapport de recherche no. 359, INRIA, 1979.

[HL90]

E.A. Heinz and P. Lukowicz. Constructing an abstract narrowing machine: A survey. Internal report 17/90, Univ. Karlsruhe, 1990.

[HL91a]

P.M. Hill and J.W. Lloyd. The Gödel Report. Univ. of Bristol, TR-91-02, 1991.

[HL91b]

G. Huet and J.-J. Lévy. Computations in orthogonal rewriting systems. In J.-L. Lassez and G. Plotkin, editors, Computational Logic: Essays in Honor of Alan Robinson, pages 395-443. MIT Press, 1991.

[HL92]

G. Hogen and R. Loogen. Pastel: A parallel stack-based implementation of eager functional programs with lazy data structures. In Proc. 4th Int. Workshop on the Parallel Implementation of Functional Languages (Aachen), 1992.

[HL93]

J. Hollman and L. Langemyr. Algorithms for non-linear algebraic constraints. In F. Benhamou and A. Colmerauer, editors, Constraint Logic Programming, pages 113-131. MIT Press, 1993.

[HL94]

P.M. Hill and J.W. Lloyd. The Gödel Programming Language. MIT Press, 1994.

[HL99]

M. Hanus and S. Lucas. A semantics for program analysis in narrowing-based functional logic languages. In Proc. 4th Fuji International Symposium on Functional and Logic Programming (FLOPS'99), pages 353-368. Springer LNCS 1722, 1999.

[HLM98]

M. Hanus, S. Lucas, and A. Middeldorp. Strongly sequential and inductively sequential term rewriting systems. Information Processing Letters, 67(1):1-8, 1998.

[HLMN96]

M. Hanus, J. Lloyd, and J.J. Moreno Navarro, editors. Integration of Functional and Logic Languages. Dagstuhl-Seminar-Report 146, 1996.

[HLS90]

P.M. Hill, J.W. Lloyd, and J.C. Sheperdson. Properties of a pruning operator. Journal of Logic and Computation, 1(1):99-143, 1990.

[HLW92a]

W. Hans, R. Loogen, and S. Winkler. On the interaction of lazy evaluation and backtracking. RWTH Aachen, 1992.

[HLW92b]

W. Hans, R. Loogen, and S. Winkler. On the interaction of lazy evaluation and backtracking. In Proc. of the 4th International Symposium on Programming Language Implementation and Logic Programming, pages 355-369. Springer LNCS 631, 1992.

[HM84]

J.R. Horgan and D.J. Moore. Techniques for improving language-based editors. In ACM, 1984.

[HM88]

J. Hannan and D. Miller. Uses of higher-order unification for implementing programs transformers. In Proc. 5th Conference on Logic Programming & 5th Symposium on Logic Programming (Seattle), pages 942-958. MIT Press, 1988.

[HM89]

T. Hickey and S. Mudambi. Global compilation of prolog. Journal of Logic Programming, 7:193-230, 1989.

[HM90]

J.S. Hodas and D. Miller. Representing objects in a logic programming language with scoping constructs. In Proc. Seventh International Conference on Logic Programming, pages 512-526. MIT Press, 1990.

[HM92a]

J. Hannan and D. Miller. From operational semantics to abstract machines. Journal of Mathematical Structures in Computer Science (to appear), 1992.

[HM92b]

J.S. Hodas and D. Miller. Logic programming in a fragment of intuitionistic linear logic. To appear in Journal of Information and Computation, 1992.

[HM93]

R. Harper and J.C. Mitchell. On the type structure of standard ml. ACM Transactions on Programming Languages and Systems, 15(2):211-252, 1993.

[HM97]

M. Hamada and A. Middeldorp. Strong completeness of a lazy conditional narrowing calculus. In Proceedings of the 2nd Fuji International Workshop on Functional and Logic Programming, pages 14-32. World Scientific, 1997.

[HMGW95]

P. Hudak, T. Makucevich, S. Gadde, and B. Whong. Haskore music notation -an algebra of music-. Journal of Functional Programming (to appear), 1995.

[HMM86]

R. Harper, D.B. MacQueen, and R. Milner. Standard ml. Lfcs report series ecs-lfcs-86-2, University of Edinburgh, 1986.

[HO80]

G. Huet and D.C. Oppen. Equations and rewrite rules: A survey. In R.V. Book, editor, Formal Language Theory: Perspectives and Open Problems. Academic Press, 1980.

[HO93]

W. Harrison and H. Ossher. Subject-oriented programming (a critique of pure objects). In Proc. OOPSLA'93, pages 411-428. ACM SIGPLAN Notices Vol. 28, No. 10, 1993.

[Hof98]

P. Hofstedt. Combining constraint solvers by projections. In Proc. of the 7th International Workshop on Functional and Logic Programming. Technical Report, Univ. M{ünster, 1998.

[H{öl87]

S. Hölldobler. Equational logic programming. In Proc. 4th IEEE Internat. Symposium on Logic Programming, pages 335-346, San Francisco, 1987.

[H{öl88]

S. Hölldobler. From paramodulation to narrowing. In Proc. 5th Conference on Logic Programming & 5th Symposium on Logic Programming (Seattle), pages 327-342, 1988.

[H{öl89]

S. Hölldobler. Foundations of Equational Logic Programming. Springer LNCS 353, 1989.

[Hon92]

H. Hong. Non-linear real constraints in constraint logic programming. In Proc. of the 3rd International Conference on Algebraic and Logic Programming, pages 201-212. Springer LNCS 632, 1992.

[Hon93]

H. Hong. Risc-clp(real): Logic programming with non-linear constraints over the reals. In F. Benhamou and A. Colmerauer, editors, Constraint Logic Programming, pages 133-159. MIT Press, 1993.

[Hoo84]

J.G. Hook. Understanding russel: A first attempt. In Semantics of Data Types, pages 69-85. Springer LNCS 173, 1984.

[HorNN]

J.J. Horning. What the compiler should tell the user, NN.

[HP95]

A. Habel and D. Plump. Unification, rewriting, and narrowing on term graphs. Electronic Notes in Theoretical Computer Science, 1995. Also in Proc. SEGRAGRA'95.

[HP96a]

M. Hanus and C. Prehofer. Higher-order narrowing with definitional trees. In Proc.\ Seventh International Conference on Rewriting Techniques and Applications (RTA'96), pages 138-152. Springer LNCS 1103, 1996.

[HP96b]

M. Hanus and C. Prehofer. Higher-order narrowing with definitional trees. Technical report 96-2, RWTH Aachen, 1996.

[HP99]

M. Hanus and C. Prehofer. Higher-order narrowing with definitional trees. Journal of Functional Programming, 9(1):33-75, 1999.

[HPJW92]

P. Hudak, S. Peyton Jones, and P. Wadler. Report on the programming language haskell (version 1.2). SIGPLAN Notices, 27(5), 1992.

[HR86]

J. Hsiang and M. Rusinowitch. A new method for establishing refutational completeness in theorem proving. In Proc. 8th Conference on Automated Deduction, pages 141-152. Springer LNCS 230, 1986.

[HR89]

M. Hermenegildo and F. Rossi. On the correctness and efficiency of independent and-parallelism in logic programs. In Proc. of the 1989 North American Conference on Logic Programming, pages 369-389. MIT Press, 1989.

[HR90]

M. Hermenegildo and F. Rossi. Non-strict independent and-parallelism. In Proc. Seventh International Conference on Logic Programming, pages 237-252. MIT Press, 1990.

[HR95]

M.V. Hermenegildo and F. Rossi. Strict and non-strict independent and-parallelism in logic programs: Correctness, efficiency, and compile-time conditions. Journal of Logic Programming, 22(1):1-45, 1995.

[HR98]

M. Hanus and P. Réty. Demand-driven search in functional logic programs. Research report rr-lifo-98-08, Univ. Orl{éans, 1998.

[HS88]

M. Höhfeld and G. Smolka. Definite relations over constraint lanugages. Lilog-report 53, IBM Deutschland, 1988.

[HS91a]

M. Hanus and A. Schwab. Alf user's manual. FB Informatik, Univ. Dortmund, 1991.

[HS91b]

M. Hanus and A. Schwab. The implementation of the functional-logic language alf. FB Informatik, Univ. Dortmund, 1991.

[HS92]

A.V. Hense and G. Smolka. A verification of extensible record types. Technical report nr. a 03/92, Univ. des Saarlandes, 1992.

[HS93a]

A.V. Hense and G. Smolka. Principal types for object-oriented languages. Technical report a 02/93, Universit{ät des Saarlandes, 1993.

[HS93b]

E. Horn and W. Schubert. Objektorientierte Software-Konstruktion. Hanser, 1993.

[HS93c]

G.M. Hoydalsvik and G. Sindre. On the purpose of object-oriented analysis. In Proc. OOPSLA'93, pages 240-255. ACM SIGPLAN Notices Vol. 28, No. 10, 1993.

[HS97]

M. Hanus and R. Sadre. A concurrent implementation of curry in java. In Proc.\ ILPS'97 Workshop on Parallelism and Implementation Technology for (Constraint) Logic Programming Languages, Port Jefferson (New York), 1997.

[HS98]

M. Hanus and F. Steiner. Controlling search in declarative programs. In Principles of Declarative Programming (Proc. Joint International Symposium PLILP/ALP'98), pages 374-390. Springer LNCS 1490, 1998.

[HS99]

M. Hanus and R. Sadre. An abstract machine for curry and its concurrent implementation in java. Journal of Functional and Logic Programming, 1999(6), 1999.

[HS00]

M. Hanus and F. Steiner. Type-based nondeterminism checking in functional logic programs. In Proc.\ of the 2nd International ACM SIGPLAN Conference on Principles and Practice of Declarative Programming (PPDP 2000), pages 202-213. ACM Press, 2000.

[HSC+96]

B.K. Holmer, B. Sano, M. Carlton, P. Van Roy, and A.M. Despain. Design and analysis of hardware for high-performance prolog. Journal of Logic Programming, 29(1-3):107-140, 1996.

[HSE90]

B. Henderson-Sellers and J.M. Edwards. The object-oriented systems life cycle. Communications of the ACM, 33(9):142-159, 1990.

[HSH90]

L. Hallnäs and P. Schroeder-Heister. A proof-theoretic approach to logic programming. i. clauses as rules. J. Logic Computat., 1(2):261-283, 1990.

[HSH91]

L. Hallnäs and P. Schroeder-Heister. A proof-theoretic approach to logic programming. ii. programs as definitions. J. Logic Computat., 1(5):635-660, 1991.

[Hsi92]

D. Hsieh. Survey of object-oriented analysis/design methodologies and future case frameworks. Technical report sri-csl-92-04, SRI International, 1992.

[HSW92]

M. Henz, G. Smolka, and J. Wuertz. Objects in oz. Slides for Workshop on Logic Programming '92, 1992.

[HSW95]

M. Henz, G. Smolka, and J. Würtz. Object-oriented concurrent constraint programming in oz. In Principles and Practice of Constraint Programming, pages 27-48. MIT Press, 1995.

[HT89]

M. Hermenegildo and E. Tick. Memory referencing characteristics and caching performance of and-parallel prolog on shared memory multiprocessors. New Generation Computing, pages 37-58, 1989.

[HT90]

P.M. Hill and R.W. Topor. A semantics for typed logic programs. Report tr-90-11, Computer Science Department, University of Bristol, 1990.

[Hud89]

P. Hudak. Conception, evolution, and application of functional programming languages. ACM Computing Surveys, 21(3):359-411, 1989.

[Hud93]

P. Hudak. Reflections on program optimization. Slides presented at WSA'93, 1993.

[Hud97]

P. Hudak. Haskore music tutorial. Technical report, Yale University, 1997.

[Hue75]

G.P. Huet. A unification algorithm for typed $λ$-calculus. Theoretical Computer Science, 1:27-57, 1975.

[Hue80]

G. Huet. Conlfuent reductions: Abstract properties and applications to term rewriting systems. Journal of the ACM, 27(4):797-821, 1980.

[Hug84]

J. Hughes. Why functional programming matters. Technical report 16, Programming Methodology Group, University of Goteborg, 1984.

[Hug90]

J. Hughes. Why functional programming matters. In D.A. Turner, editor, Research Topics in Functional Programming, pages 17-42. Addison Wesley, 1990.

[Hug98]

J. Hughes. Generalising monads to arrows. Submitted for publication, 1998.

[Hul80]

J.-M. Hullot. Canonical forms and unification. In Proc. 5th Conference on Automated Deduction, pages 318-334. Springer LNCS 87, 1980.

[Hun86]

M.M. Huntbach. An improved version of shapiro's model inference system. In Proc. Third International Conference on Logic Programming (London), pages 180-187. Springer LNCS 225, 1986.

[Hus85]

H. Hussmann. Unification in conditional-equational theories. In Proc. EUROCAL '85, pages 543-553. Springer LNCS 204, 1985.

[Hus89]

H. Hussmann. Rapid prototyping for algebraic specifications: Rap system user's manual. Univ. Passau, 1989.

[Hus92]

H. Hussmann. Nondeterministic algebraic specifications and nonconfluent term rewriting. Journal of Logic Programming, 12:237-255, 1992.

[HV87a]

M. Huber and I. Varsek. Epos: Extended prolog with order-sorted resolution. Internal report 4/87, Univ. Karlsruhe, 1987.

[HV87b]

M. Huber and I. Varsek. Extended prolog with order-sorted resolution. In Proc. 4th IEEE Internat. Symposium on Logic Programming, pages 34-43, San Francisco, 1987.

[HvdGB93]

S. Hong, G. van den Goor, and S. Brinkkemper. A formal approach to the comparison of object-oriented analysis and design methodologies. In Proc. HICSS-26, 1993.

[HVRS97]

S. Haridi, P. Van Roy, and G. Smolka. An overview of the design of distributed oz. In Proc. 2nd International Symposium on Parallel Symbolic Computation (PASCO'97), pages 176-187. ACM Press, 1997.

[HW92]

W. Hans and S. Winkler. Aliasing and groundness analysis of logic programs through abstract interpretation and its safety. Technical report 92-27, RWTH Aachen, 1992.

[HW93]

W. Hans and S. Winkler. Abstract interpretation of functional logic languages. Technical report, RWTH Aachen, 1993.

[HWD92a]

M.V. Hermenegildo, R. Warren, and S.K. Debray. Global flow analysis as a practical compilation tool. To appear in Journal of Logic Programming, 1992.

[HWD92b]

M.V. Hermenegildo, R. Warren, and S.K. Debray. Global flow analysis as a practical compilation tool. Journal of Logic Programming, 13(4):349-366, 1992.

[HZ94]

M. Hanus and F. Zartmann. Mode analysis of functional logic programs. In Proc. 1st International Static Analysis Symposium, pages 26-42. Springer LNCS 864, 1994.

[icl90]

Proc. Seventh International Conference on Logic Programming. MIT Press, 1990.

[icl91]

Proc. Int. Conference on Logic Programming (Paris). MIT Press, 1991.

[ilp91]

Proc. 1991 International Logic Programming Symposium. MIT Press, 1991.

[Imb90]

J.-L. Imbert. About redundant inequalities generated by fourier's algorithm. Published in AIMSA Congress, 1990.

[IMM88]

P. Inverardi, S. Martini, and C. Montangero. Is type checking practical for system configuration?. Technical report tr-12/88, Univ. Pisa, 1988. Also in Proc. Tapsoft'89.

[IN94]

T. Ida and K. Nakahara. Leftmost outside-in narrowing calculi. Technical report ise-tr-94-107, University of Tsukuba, 1994.

[IN97]

T. Ida and K. Nakahara. Leftmost outside-in narrowing calculi. Journal of Functional Programming, 7(2):129-161, 1997.

[Ind88]

K. Indermark. Functional compiler description. Volume 21, Banach Center Publications, Warsaw, 1988.

[IO94a]

T. Ida and S. Okui. Outside-in conditional narrowing. Research report ise-tr-94-106, Univ. of Tsukuba, 1994.

[IO94b]

T. Ida and S. Okui. Outside-in conditional narrowing (revised version). IEICE Transactions Information & Systems, E77-D(6), 1994.

[Jac90]

D. Jacobs. Type declarations as subtype constraints in logic programming. In ACM SIGPLAN'90 Conference PLDI, SIGPLAN Notices Vol. 25 No. 6, pages 165-173, 1990.

[Jac92]

I. Jacobson. Object-Oriented Software Engineering. A Use Case Driven Approach. Addison-Wesley, 1992.

[Jan94a]

S. Janson. AKL - A Multiparadigm Programming Language. PhD thesis, Swedish Institute of Computer Science, 1994.

[Jan94b]

S. Janson. Implementation of andorra-based languages. Tutorial notes presented at ICLP'94, 1994.

[Jas90]

H. Jasper. Datenbankunterstützung für prolog-programmierumgebungen. Report 5/90, Univ. Oldenburg, 1990.

[JB89]

G. Janssens and M. Bruynooghe. An application of abstract interpretation: Integrated type and mode inferencing. Report cw86, Katholieke Univ. Leuven, 1989.

[JB92]

G. Janssens and M. Bruynooghe. Deriving descriptions of possible values of program variables. Journal of Logic Programming, 13(2 & 3):205-258, 1992.

[JD86]

A. Josephson and N. Dershowitz. An implementation of narrowing: The rite way. In Proc. IEEE Internat. Symposium on Logic Programming, pages 187-197, Salt Lake City, 1986.

[JD89]

A. Josephson and N. Dershowitz. An implementation of narrowing. Journal of Logic Programming (6), pages 57-77, 1989.

[JDM88]

G. Janssens, B. Demoen, and A. Marien. Improving the register allocation in wam by reordering unification. In Proc. 5th Conference on Logic Programming & 5th Symposium on Logic Programming (Seattle), pages 1388-1402. MIT Press, 1988.

[Je96]

A. Jung (ed.). Domains and denoatational semantics: History, accomplishments and open problems. Bulletin of the EATCS, (59):227-256, 1996.

[JGCH89]

D. Jamsek, K.J. Greene, S.-K. Chin, and P.R. Humenn. Winter: Wams in tim expression reduction. In Proc. of the 1989 North American Conference on Logic Programming, pages 1013-1029. MIT Press, 1989.

[JH91]

S. Janson and S. Haridi. Programming paradigms of the andorra kernel language. In Proc. 1991 International Logic Programming Symposium, pages 167-183. MIT Press, 1991.

[JH94]

S. Janson and S. Haridi. An introduction to akl: A multi-paradigm programming language. In B. Mayoh, E. Tyugu, and J. Penjam, editors, Constraint Programming, NATO ASI Series, pages 414-449. Springer, 1994.

[JJ97]

P. Jansson and J. Jeuring. Polyp - a polytypic programming language extension. In Proc.\ of the 24th ACM Symposium on Principles of Programming Languages (Paris), pages 470-482, 1997.

[JK84]

J.P. Jouannaud and H. Kirchner. Completion of a set of rules modulo a set of equations. In Proc. 11th ACM Symposium on Principles of Programming Languages, pages 83-92, Salt Lake City, Utah, 1984.

[JK86]

J.-P. Jouannaud and H. Kirchner. Completion of a set of rules modulo a set of equations. SIAM Journal on Computing, 15(4):1155-1194, 1986.

[JK91]

J.-P. Jouannaud and C. Kirchner. Solving equations in abstract algebras: A rule-based survey of unification. In J.-L. Lassez and G. Plotkin, editors, Computational Logic: Essays in Honor of Alan Robinson, pages 257-321. MIT Press, 1991.

[JL87]

J. Jaffar and J.-L. Lassez. Constraint logic programming. In Proc. of the 14th ACM Symposium on Principles of Programming Languages, pages 111-119, Munich, 1987.

[JL88]

D. Jacobs and A. Langen. Compilation of logic programs for restricted and-parallelism. In Proc. ESOP'88, pages 284-297. Springer LNCS 300, 1988.

[JL89]

D. Jacobs and A. Langen. Accurate and efficient approximation of variable aliasing in logic programs. In Proc. of the 1989 North American Conference on Logic Programming, pages 154-165. MIT Press, 1989.

[JLM84]

J. Jaffar, J.-L. Lassez, and M.J. Maher. A theory of complete logic programs with equality. Journal of Logic Programming, 1:211-223, 1984.

[JLM86a]

J. Jaffar, J.-L. Lassez, and M.J. Maher. Logic programming language scheme. In D. DeGroot and G. Lindstrom, editors, Logic Programming, Functions, Relations, and Equations, pages 441-467. Prentice Hall, 1986.

[JLM86b]

J. Jaffar, J.-L. Lassez, and M.J. Maher. Some issues and trends in the semantics of logic programming. In Proc. Third International Conference on Logic Programming (London), pages 223-241. Springer LNCS 225, 1986.

[JM84]

N.D. Jones and A. Mycroft. Stepwise development of operational and denotational semantics for prolog. In Proc. IEEE Internat. Symposium on Logic Programming, pages 281-288, Atlantic City, 1984.

[JM87]

J. Jaffar and S. Michaylov. Methodology and implementation of a clp system. In Proc. 4th IEEE Internat. Symposium on Logic Programming, pages 196-218, San Francisco, 1987.

[JM94]

J. Jaffar and M.J. Maher. Constraint logic programming: A survey. Journal of Logic Programming, 19&20:503-581, 1994.

[JMH93]

S. Janson, J. Montelius, and S. Haridi. Ports for objects in concurrent logic programs. In Research Directions in Concurrent Object-Oriented Programming. MIT Press, 1993.

[JMM91]

N. Jørgensen, K. Marriott, and S. Michaylov. Some global compile-time optimizations for clp($\cal r$). In Proc. 1991 International Logic Programming Symposium, pages 420-434. MIT Press, 1991.

[JMMCMN92]

J.A. Jiménez-Martin, J. Marino-Carballo, and J.J. Moreno-Navarro. Efficient compilation of lazy narrowing into prolog. In Proc. Int. Workshop on Logic Program Synthesis and Transformation (LOPSTR'92), pages 253-270. Springer Workshops in Computing Series, 1992.

[JMSY92a]

J. Jaffar, S. Michaylov, P.J. Stuckey, and R.H.C. Yap. An abstract machine for clp($\cal r$). In Proc. SIGPLAN Conference on Programming Language Design and Implementation, pages 128-139. SIGPLAN Notices, Vol. 27, No. 7, 1992.

[JMSY92b]

J. Jaffar, S. Michaylov, P.J. Stuckey, and R.H.C. Yap. The clp($\cal r$) language and system. ACM Transactions on Programming Languages and Systems, 14(3):339-395, 1992.

[JMY91]

J. Jaffar, S. Michaylov, and R.H.C. Yap. A methodology for managing hard constraints in clp systems. In Proc. ACM SIGPLAN'91 Conference on Programming Language Design and Implementation, pages 306-316. SIGPLAN Notices, Vol. 26, No. 6, 1991.

[JN91]

B. Jayaraman and G. Nadathur. Implementation techniques for scoping constructs in logic programming. Report cs-1991-10, Duke University, 1991.

[JO91]

J.-P. Jouannaud and M. Okada. A computation model for executable higher-order algebraic specification languages. In Proc. LICS'91, pages 350-361, 1991.

[Joh85]

T. Johnsson. Lambda lifting: Transforming programs to recursive functions. In Functional Programming Languages and Computer Architecture, pages 190-203. Springer LNCS 201, 1985.

[Jon93a]

M.P. Jones. A system of constructor classes: overloading and implicit higher-order polymorphism. In Proc. Conference on Functional Programming Languages and Computer Architecture (FPCA'93), 1993.

[Jon93b]

N.D. Jones. Constant time factors do matter. In ACM Symposium on Theory of Computing, 1993.

[Jon95]

M.P. Jones. A system of constructor classes: overloading and implicit higher-order polymorphism. Journal of Functional Programming, 5(1):1-35, 1995.

[Jor90]

D. Jordan. Implementation benefits of c++ language mechanisms. Communications of the ACM, 33(9):61-64, 1990.

[Jos92]

B. Josephs. The development of a debugger for the functional logic language alf (in german). Diploma thesis, Univ. Dortmund, 1992.

[JP89]

B. Jayaraman and D.A. Plaisted. Programming with equations, subsets, and relations. In Proc. of the 1989 North American Conference on Logic Programming, pages 1051-1068. MIT Press, 1989.

[JP92]

R. Jagadeesan and K. Pingali. Abstract semantics for a higher-order functional language with logic variables. In Proc. POPL'92, 1992.

[JPP91]

R. Jagadeesan, K. Pingali, and P. Panangaden. A fully abstract semantics for a first-order functional language with logic variables. ACM Transactions on Programming Languages and Systems, 13(4):577-625, 1991.

[JS86a]

J. Jaffar and P.J. Stuckey. Logic program semantics for programming with equations. In Proc. Third International Conference on Logic Programming (London), pages 313-326. Springer LNCS 225, 1986.

[JS86b]

B. Jayaraman and F.S.K. Silbermann. Equations, sets, and reduction semantics for functional and logic programming. In Proc. of the 1986 ACM Conference on LISP and Functional Programming, pages 320-331, 1986.

[JS87]

N. Jones and H. Søndergaard. A semantics-based framework for the abstract interpretation of prolog. In S. Abramsky and C. Hankin, editors, Abstract Interpretation of Declarative Languages, pages 123-142. Ellis Horwood, 1987.

[JS92]

M. Jeusfeld and M. Staudt. Query optimization in deductive object bases. In Freytag, Maier, and Vossen, editors, Query processing in object-oriented, complex-object, and nested relation databases. Morgan Kaufmann, 1992.

[JS94a]

G. Janssens and W. Simoens. On the implementation of abstract interpretation systems for (constraint) logic programs. In Proc.\ 5th International Conference on Compiler Construction, pages 172-187. Springer LNCS 786, 1994.

[JS94b]

J.-P. Jouannaud and W. Sadfi. Strong sequentiality of left-linear overlapping rewrite systems. In Fourth Int. Workshop on Conditional Term Rewriting Systems. Springer LNCS (to appear), 1994.

[JSS85]

N.D. Jones, P. Sestoft, and H. Søndergaard. An experiment in partial evaluation: The generation of a compiler generator. In Rewriting Techniques and Applications, pages 124-140. Springer LNCS 202, 1985.

[JT84]

N.D. Jones and M. Tofte. Towards a theory of compiler generation. Workshop notes, 1984.

[JvdBvdH93]

S. Joosten, K. van der Bert, and G. van der Hoeven. Teaching functional programming to first-year students. Journal of Functional Programmming, 3(1):49-65, 1993.

[JW81]

G. Jochum and W. Willmertinger. A tool for developing text processing systems: Trnaslator writing systems. Technical report tum-i8103, TU M{ünchen, 1981.

[JW86]

J.-P. Jouannaud and B. Waldmann. Reductive conditional term rewriting systems. In Proc. Third IFIP Working Conference on Formal Description of Programming Concepts, Ebberup, Denmark, 1986.

[KA95]

H. Kuchen and J. Anastasiadis. Higher order babel: Language and implementation. Technical report, RWTH Aachen, 1995.

[KA96]

H. Kuchen and J. Anastasiadis. Higher order babel: Language and implementation. In Proc. 5th International Workshop on Extensions of Logic Programming, pages 193-207. Springer LNAI 1050, 1996.

[Kah86]

K.M. Kahn. Uniform: A language based upon unification which unifies (much of) lisp, prolog, and act1. In D. DeGroot and G. Lindstrom, editors, Logic Programming, Functions, Relations, and Equations, pages 411-438. Prentice Hall, 1986.

[Kah95]

K. Kahn. Toontalk: Concurrent constraint programming for children. Slides presented at ICLP'95, 1995.

[Kam88]

S. Kamin. Inheritance in smalltalk-80: A denotational definition. In Proc. POPL'88, pages 80-87, 1988.

[Kap84a]

S. Kaplan. Conditional rewrite rules. Theoretical Computer Science 33, pages 175-193, 1984.

[Kap84b]

S. Kaplan. Fair conditional term rewriting systems: Unification, termination and confluence. Report 194, L.R.I., Université de Paris-Sud, 1984.

[Kap87a]

S. Kaplan. A compiler for conditional term rewriting systems. In Proc. RTA'87, pages 25-41. Springer LNCS 256, 1987.

[Kap87b]

S. Kaplan. Simplifying conditional term rewriting systems: Unification, termination, and confluence. Journal of Symbolic Computation, 4(3):295-334, 1987.

[Kap90]

A.M. Kappel. Algebraische operational semantik und ihre anwendung auf prolog. Diplomarbeit, Univ. Dortmund, 1990.

[Kau92]

M. Kaufmann. Response to fm91 survey of formal methods: Nqthm and pc-nqthem. Technical report 75, Computational Logic Inc., Austin (Texas), 1992.

[KB70]

D.E. Knuth and P.B. Bendix. Simple word problems in universal algebras. In J. Leech, editor, Computational Problems in Abstract Algebra, pages 263-297. Pergamon Press, 1970.

[KB91]

S. Krischer and A. Bockmayr. Detecting redundant narrowing derivations by the lse-sl reducibility test. In Proc. RTA'91. Springer LNCS 488, 1991.

[KB92]

A. Krall and T. Berger. Fast prolog with a vam$_1p$ based prolog compiler. In Proc. of the 4th International Symposium on Programming Language Implementation and Logic Programming, pages 245-259. Springer LNCS 631, 1992.

[KC84]

K.M. Kahn and M. Carlsson. The compilation of prolog programs without the use of a prolog compiler. In Proc. Int. Conf. on Fifth Generation Computer Systems, pages 348-355. ICOT, 1984.

[KCR98]

R. Kelsey, W. Clinger, and J. Rees. Revised$^5$ report on the algorithmic language scheme. ACM SIGPLAN Notices, 33(9):26-76, 1998.

[Ker81]

B.W. Kernighan. Why pascal is not my favorite programming language. Technical report, AT&T Bell Laboratories, 1981.

[Ker82]

B.W. Kernighan. Typesetting mathematics, tables and diagrams. In Textverarbeitung und B{ürosysteme, pages 177-192. Oldenbourg, Lectures and Tutorials, Vol. 13, 1982.

[Kes91]

D. Kesner. Pattern matching in order-sorted languages. Research report 10, Digital Paris Research Laboratory, 1991.

[KH69]

R. Kowalski and P.J. Hayes. Semantic trees in automatic theorem-proving. In B. Meltzer and D. Michie, editors, Machine Intelligence 4, pages 87-101, 1969.

[KH85]

T. Kanamori and K. Horiuchi. Type inference in prolog and its application. In Proc. 9th IJCAI, pages 704-707. W. Kaufmann, 1985.

[KH90]

H. Kuchen and W. Hans. An and-parallel implementation of the functional logic language babel. RWTH Aachen, 1990.

[Kil90]

M. Kilian. Trellis: Turning designs into programs. Communications of the ACM, 33(9):65-67, 1990.

[Kin93]

A. King. A framework for sharing analysis. Univ. of Southampton, 1993.

[Kir86]

C. Kirchner. Computing unification algorithms. In Proc. LICS'86, pages 206-216, 1986.

[Kir89]

H. Kirchner. Schematization of infinite sets of rewrite rules generated by divergent completion processes. Theoretical Computer Science, 67:303-332, 1989.

[Kir91]

H. Kirchner. Proofs in parameterized specifications. In Proc. RTA'91, pages 174-187. Springer LNCS 488, 1991.

[KK71]

R. Kowalski and D. Kuehner. Linear resolution with selection function. Artificial Intelligence, 2:227-260, 1971.

[KK91]

A. K\aagedal and F. Klu\'zniak. Enriching prolog with s-unification. In J. Darlington and R. Dietrich, editors, Workshop on Declarative Programming, pages 51-65. Springer, Workshops in Computing, 1991.

[KKM88]

C. Kirchner, H. Kirchner, and J. Meseguer. Operational semantics of obj3 (extended abstract). In Proc. of the 15th ICALP, pages 287-301. Springer LNCS 317, 1988.

[KKR90]

C. Kirchner, H. Kirchner, and M. Rusinowitch. Deduction with symbolic constraints. Technical report, INRIA & CRIN, 1990.

[Kle91]

C. Klein. Automatic exploitation of or-parallelism in prolog. Univ. of Cambridge, 1991.

[KLF92]

H. Kuchen and F.J. Lopez-Fraguas. Result directed computing in a functional logic language. Technical report 92-21, RWTH Aachen, 1992.

[KLFMNRA92a]

H. Kuchen, F.J. López-Fraguas, J.J. Moreno-Navarro, and M. Rodr\'\iguez-Artalejo. Implementing a lazy functional logic language with disequality constraints. In Proc. of the 1992 Joint International Conference and Symposium on Logic Programming. MIT Press, 1992.

[KLFMNRA92b]

H. Kuchen, F.J. López-Fraguas, J.J. Moreno-Navarro, and M. Rodr\'\iguez-Artalejo. Implementing disequality in a lazy functional logic language. Technical report nr. 92-20, RWTH Aachen, 1992.

[KLMNRA92]

H. Kuchen, R. Loogen, J.J. Moreno-Navarro, and M. Rodriguez-Artalejo. Graph-narrowing to implement a functional logic language. Technical report, Universidad Politecnica de Madrid, 1992.

[KLMNRA96]

H. Kuchen, R. Loogen, J.J. Moreno-Navarro, and M. Rodr\'\iguez-Artalejo. The functional logic language babel and its implementation on a graph machine. New Generation Computing, 14:391-427, 1996.

[KLMR89]

H. Kuchen, R. Loogen, J.J. Moreno-Navarro, and M. Rodr\'\iguez-Artalejo. Graph-based implementation of a functional logic language. Report no. 89-20, RWTH Aachen, 1989.

[KLMR90]

H. Kuchen, R. Loogen, J.J. Moreno-Navarro, and M. Rodr\'\iguez-Artalejo. Graph-based implementation of a functional logic language. In Proc. ESOP 90, pages 271-290. Springer LNCS 432, 1990.

[Klo87]

J.W. Klop. Term rewriting systems: a tutorial. EATCS Bulletin, 1987.

[Klo89]

J.W. Klop. Term rewriting in equational logic programming. Tutorial notes for ICLP'89, 1989.

[Klo92]

J.W. Klop. Term rewriting systems. In S. Abramsky, D. Gabbay, and T. Maibaum, editors, Handbook of Logic in Computer Science, volume II. Oxford University Press, 1992.

[KLS92]

P.J. Koopman, P. Lee, and D.P. Siewiorek. Cache behavior of combinator graph reduction. ACM Transactions on Programming Languages and Systems, 14(2):265-297, 1992.

[{Klu}87]

F. Klu\'zniak. Type synthesis for ground prolog. In Proc. Fourth International Conference on Logic Programming (Melbourne), pages 788-816. MIT Press, 1987.

[{Klu}88]

F. Klu\'zniak. Compile time garbage collection for ground prolog. In Proc. 5th Conference on Logic Programming & 5th Symposium on Logic Programming (Seattle), pages 1490-1505, 1988.

[KM86]

H.J. Komorowski and J. Maluszynski. Logic programming and rapid prototyping. Report tr-01-86, Harvard Univ., 1986.

[KM87]

D. Kapur and D.R. Musser. Proof by consistency. Artifical Intelligence, 31:125-157, 1987.

[KM90a]

M. Korsloot and H.M. Mulder. Sequential architecture models for prolog: A performance comparison. In Proc. Seventh International Conference on Logic Programming, pages 49-66. MIT Press, 1990.

[KM90b]

T. Korson and J.D. McGregor. Understanding object-oriented: A unifying paradigm. Communications of the ACM, 33(9):40-60, 1990.

[KM93]

A. Kemper and G. Moerkotte. Basiskonzepte objektorientierter datenbanksysteme. Informatik-Spektrum, 16(2):69-80, 1993.

[KM94]

A.C. Kakas and P. Mancarella. Abduction and abductive logic programming. Tutorial notes presented at ICLP'94, 1994.

[KMNH92]

H. Kuchen, J.J. Moreno-Navarro, and M.V. Hermenegildo. Independent and-parallel implementation of narrowing. In Proc. of the 4th International Symposium on Programming Language Implementation and Logic Programming, pages 24-38. Springer LNCS 631, 1992.

[KN90]

A. Krall and U. Neumerkel. The vienna abstract machine. In Proc. of the 2nd Int. Workshop on Programming Language Implementation and Logic Programming, pages 121-135. Springer LNCS 456, 1990.

[Knu68]

D.E. Knuth. Semantics of context-free languages. Mathematical Systems Theory, 2(2):127-145, 1968.

[Knu78]

D.E. Knuth. Tau espilon chi, a system for technical text. Memo aim-317.1, Stanford Artificial Intelligence Laboratory, 1978.

[KNW91]

K. Kwon, G. Nadathur, and D.S. Wilson. Implementing logic programming languages with polymorphic typing. Report cs-1991-39, Duke University, 1991.

[KNW94]

K. Kwon, G. Nadathur, and D.S. Wilson. Implementating polymorphic typing in a logic programming language. Computer Languages, 20(1):25-42, 1994.

[KO85]

H.J. Komorowski and S. Omori. A model and an implementation of a logic programming environment. In Proc. ACM SIGPLAN'85 Conference, 1985.

[Koc92]

P. Koch. Intelligentes backtracking bei der auswertung funktional-logischer programme. Technical report 92-39, RWTH Aachen, 1992.

[Koj00]

J. Koj. A graphical programming environment for declarative programming languages (in german). Master's thesis, RWTH Aachen, 2000.

[Kom82]

H.J. Komorowski. Partial evaluation as a means for inferencing data structures in an applicative language: A theory and implementation in the case of prolog. In Proc. 9th POPL, pages 255-267, 1982.

[Kom86]

H.J. Komorowski. A declarative logic programming environment. Report tr-06-86, Harvard Univ., 1986.

[Kom89]

J. Komorowski. Synthesis of programs in the framework of partial deduction. Report no 81, Abo Akademi, Finland, 1989.

[Kor85]

R.E. Korf. Depth-first iterative-deepening: An optimal admissible tree search. Artifical Intelligence, 27:97-109, 1985.

[Kor86]

W.A. Kornfeld. Equality for prolog. In D. DeGroot and G. Lindstrom, editors, Logic Programming, Functions, Relations, and Equations, pages 279-293. Prentice Hall, 1986.

[Kow74]

R. Kowalski. Predicate logic as programming language. In Proc. IFIP '74, pages 569-574. North-Holland, 1974.

[Kow79]

R. Kowalski. Algorithm = logic + control. Communications of the ACM, 22(7):424-436, 1979.

[Kow88]

R. Kowalski. The early years of logic programming. Communications of the ACM, 31(1):38-43, 1988.

[KP88]

G. Krasner and S. Pope. A cookbook for using the model-view-controller user interface in smalltalk-80. Journal of Object-Oriented Programming, 1(3):26-49, 1988.

[KQ90]

H.-J. Kreowski and Z. Qian. Relation-sorted algebraic specifications with built-in coercers: Basic notions and results. In Proc. STACS'90, pages 165-175. Springer LNCS 415, 1990.

[KR83]

B.W. Kernighan and D.M. Ritchie. Programmieren in C. Hanser Verlag, 1983.

[KR91]

E. Kounalis and M. Rusinowitch. On word problems in horn theories. J. of Symbolic Computation, 1991.

[KR93]

H. Kirchner and C. Ringeissen. Constraint solving by narrowing in combined algebraic domains. CRIN-CNRS & INRIA Lorraine, 1993.

[KR94]

H. Kirchner and C. Ringeissen. Constraint solving by narrowing in combined algebraic domains. In Proc. Eleventh International Conference on Logic Programming, pages 617-631. MIT Press, 1994.

[Kra86]

A. Krall. Comparing implementation techniques for prolog. Report vip tr 1802/86/7, TU Wien, 1986.

[Kra87]

A. Krall. Implementation of a high-speed prolog interpreter. In SIGPLAN'87 Symposium on Interpreters and Interpretive Technqiues, pages 125-131. ACM SIGPLAN Notices Vol. 22, No. 7, 1987.

[Kra96]

A. Krall. The vienna abstract machine. Journal of Logic Programming, 29(1-3):85-106, 1996.

[KS85]

F. Klu\'zniak and S. Szpakowicz. Prolog for Programmers. Academic Press, London, 1985.

[KS94]

H. Kuchen and H. Stoltze. Candela - a topology description language. Computers and Artificial Intelligence, 13(6):557-576, 1994.

[KSKH85]

M. Kishimoto, T. Shinogi, Y. Kimura, and A. Hattori. Design and evaluation of a prolog compiler. In Logic Programming '85 (Tokyo), pages 192-203. Springer LNCS 221, 1985.

[KSS98]

A. Kutzner and M. Schmidt-Schau\ss. A non-deterministic call-by-need lambda calculus. In Proc. of the International Conference on Functional Programming (ICFP'98), pages 324-335. ACM SIGPLAN Notices 34(1), 1998.

[KTU88a]

A.J. Kfoury, J. Tiuryn, and P. Urzyczyn. On the computational power of universally polymorphic recursion. In Proc. LICS'88, pages 72-81, 1988.

[KTU88b]

A.J. Kfoury, J. Tiuryn, and P. Urzyczyn. A proper extension of ml with an effective type-assignment. In Proc. of the 15th ACM Symposium on Principles of Programming Languages, pages 58-69, San Diego, 1988.

[KTU90]

A.J. Kfoury, J. Tiuryn, and P. Urzyczyn. The undecidability of the semi-unification problem. In Proc. 22nd ACM Symposium on Theory of Computing, pages 468-476, 1990.

[KTU93]

A.J. Kfoury, J. Tiuryn, and P. Urzyczyn. Type recursion in the presence of polymorphic recursion. ACM Transactions on Programming Languages and Systems, 15(2):290-311, 1993.

[KTW+86]

Y. Kaneda, N. Tamura, K. Wada, H. Matsuda, S. Kuo, and S. Maekawa. Sequential prolog machine pek. New Generation Computing, 4(1):51-66, 1986.

[Kuc95]

H. Kuchen. Implementation issues for functional logic programming. Slides presented at ILPS'95, 1995.

[K{üh94]

T. Kühne. Higher order objects in pure object-oriented languages. ACM SIGPLAN Notices, 29(7):15-20, 1994.

[Kum92]

V. Kumar. Algorithms for constraint satisfaction problems: A survey. AI Magazine, 13(1):32-44, 1992.

[Kun87]

K. Kunen. Negation in logic programming. Journal of Logic Programming, 4:289-308, 1987.

[Kun89]

K. Kunen. Logic for logic programmers. Technical report #884, Univ. of Wisconsin-Madison, 1989.

[Kur86]

P. Kursawe. How to invent a prolog machine. In Proc. Third International Conference on Logic Programming (London), pages 134-148. Springer LNCS 225, 1986.

[Kur87]

P. Kursawe. How to invent a prolog machine. New Generation Computing, 5(1):97-114, 1987.

[Kur90]

P. Kursawe. Teilweise Auswertung zur Konstruktion von Zwischensprachen. Gmd-bericht nr. 187, Univ. Karlsruhe, 1990.

[Kur92]

S. Kurtz. Narrowing and basic forward closures. Technical report, Univ. Bielefeld, 1992.

[KV92]

T.D. Korson and V.K. Vaishnavi. Managing emerging software technologies: A technology transfer framework. Communications of the ACM, 35(9):101-111, 1992.

[KvdW89]

C.H.A. Koster and T.P. van der Weide. Elan 1.5 manual. Technical report, Univ. of Nijmegen, 1989.

[KW76]

K. Kennedy and S.K. Warren. Automatic generation of efficient evaluators for attribute grammars. In Conf. Record of the Third ACM Symposium on Principles of Programming Languages, pages 32-49, 1976.

[KW91]

M. Kifer and J. Wu. A first-order theory of types and polymorphism in logic programming. In Proc. LICS'91, pages 310-321, 1991.

[KYAB88]

K. Kurosawa, S. Yamaguchi, S. Abe, and T. Bandoh. Instruction architecture for a high performance integrated prolog processor ipp. In Proc. 5th Conference on Logic Programming & 5th Symposium on Logic Programming (Seattle), pages 1506-1530, 1988.

[Lam83]

D.A. Lamb. Sharing intermediate representations: The interface description language. Technical report cmu-cs-83 129, Carnegie-Mellon University, 1983.

[Lau86]

S. Launay. Complétion de systèmes de réécriture types dont les fonctions sont polymorphes (Thèse de 3ème cycle). Technical report 86-5, C.N.R.S Université Paris VII, 1986.

[Lau93]

J. Launchbury. A natural semantics for lazy evaluation. In Proc. 20th ACM Symposium on Principles of Programming Languages (POPL'93), 1993.

[Lav88]

A. Laville. Implementation of lazy pattern matching algorithms. In Proc. ESOP 88, Nancy, pages 288-316. Springer LNCS 300, 1988.

[LBD+87]

N. Lindenberg, A. Bockmayr, R. Dietrich, P. Kursawe, B. Neidecker, C. Scharnhorst, and I. Varsek. Ka-prolog: Sprachdefinition. Technical report 5/87, Univ. Karlsruhe, 1987.

[LCMVH90]

B. Le Charlier, K. Musumbu, and P. Van Hentenryck. Efficient and accurate algorithms for the abstract interpretation of prolog programs. Research paper no rp-90/9, Univ. of Namur, 1990.

[LCMVH91]

B. Le Charlier, K. Musumbu, and P. Van Hentenryck. A generic abstract interpretation algorithm and its complexity analysis. In Proc. International Conference on Logic Programming, pages 64-78. MIT Press, 1991.

[LCR92]

B. Le Charlier and S. Rossi. An accurate abstract interpretation framework for prolog with cut. Univ. of Namur, 1992.

[LCVH94]

B. Le Charlier and P. Van Hentenryck. Experimental evaluation of a generic abstract interpretation algorithm for prolog. ACM Transactions on Programming Languages and Systems, 16(1):35-101, 1994.

[LDS97]

M. Leuschel and D. De Schreye. Constrained partial deduction. In Proc. WLP'97, 1997.

[Lea88]

E. Lusk and et al. The aurora or-parallel prolog system. In Proc. FGCS'88, pages 819-830, 1988.

[Led98]

P. Ledru. Jspace: Implementation of a linda system in java. ACM SIGPLAN Notices, 33(8):48-50, 1998.

[Lei83]

D. Leivant. Polymorphic type inference. In Proc. 10th POPL, pages 88-98, 1983.

[Lei90]

H. Lei\ss. Polymorphic recursion and semi-unification. In CSL'90 (????), pages 211-224, 1990.

[Leu94]

M. Leuschel. Partial evaluation of the ``Real Thing''. In Proc. LOPSTR'94, pages 122-137. Springer LNCS 883, 1994.

[Lev85]

J. Levy. A ghc abstract machine and instruction set. Report cs85-11, Weizmann Institute of Science, 1985.

[Lev86]

J. Levy. A ghc abstract machine and instruction set. In Proc. Third International Conference on Logic Programming (London), pages 157-171. Springer LNCS 225, 1986.

[LF92]

F.J. López Fraguas. A general scheme for constraint functional logic programming. In Proc. of the 3rd International Conference on Algebraic and Logic Programming, pages 213-227. Springer LNCS 632, 1992.

[LFRA91]

F.J. López Fraguas and M. Rodr\'\iguez-Artalejo. An approach to constraint functional logic programming. Technical report dia/91/4, Universidad Complutense, Madrid, 1991.

[LFSH99]

F. López-Fraguas and J. Sánchez-Hernández. TOY: A Multiparadigm Declarative System. In Proc. of RTA'99, pages 244-247. Springer LNCS 1631, 1999.

[LFSH00]

F.J. López-Fraguas and J. Sánchez-Hernández. Proving failure in functional logic programs. In Proc. First International Conference on Computational Logic (CL 2000), pages 179-183. Springer LNAI 1861, 2000.

[LG88]

J.M. Lucassen and D.K. Gifford. Polymorphic effect systems. In Proc.\ of the 15th ACM Symposium on Principles of Programming Languages, pages 47-57. ACM Press, 1988.

[LG97a]

L. Lafave and J.P. Gallagher. Constraint-based partial evaluation of rewriting-based functional logic programs. In Proc. LOPSTR'97, pages 168-188. Springer LNCS 1463, 1997.

[LG97b]

L. Lafave and J.P. Gallagher. Partial evaluation of functional logic programs in rewriting-based languages. Technical report cstr-97-001, University of Bristol, 1997.

[LHR88]

K. Lieberherr, I. Holland, and A. Riel. Object-oriented programming: An objective sense of style. In Proc. OOPSLA'88, pages 323-334. SIGPLAN Notices 23(11), 1988.

[Lin87]

T.-W. Ling. Integrity constraint checking in deductive databases using the prolog not-predicate. Data & Knowledge Engineering, 2:145-168, 1987.

[Lin93a]

H. Lin. Procedural implementation of algebraic specification. ACM Transactions on Programming Languages and Systems, 15(5):876-895, 1993.

[Lin93b]

C. Lindig. Style: A practical type checker for scheme. Technical report 93-10, TU Braunschweig, 1993.

[Lip83]

U. Lipeck. Ein algeraischer Kalkül für einen strukturierten Entwurf von Datenabstraktionen. PhD thesis, Univ. Dortmund, 1983. Forschungsbericht Nr. 148.

[LK90]

N. Lichtenstein and S. Kaplan. Fpl: Functional plus logic programming. an integration of the fp and prolog languages. In 2nd Int. Workshop on Conditional and Typed Rewriting Systems, pages 407-416. Springer LNCS 516, 1990.

[LK92a]

B. Liu and Y.-W. Ku. Constraintlisp: An object-oriented constraint programming language. ACM SIGPLAN Notices, 27(11):17-26, 1992.

[LK92b]

S. Lüttringhaus-Kappel. Laziness in Logic Programming. PhD thesis, Univ. Bonn, 1992.

[LKID89]

R. Loogen, H. Kuchen, K. Indermark, and W. Damm. Distributed implementation of programmed graph reduction. In Proc. PARLE'89, pages 136-157. Springer LNCS 365, 1989.

[LL88]

T. Lehmann and J. Loeckx. The specification language of obscure. In 5th Workshop on Specification of Abstract Data Types, pages 131-153. Springer LNCS 332, 1988.

[LL90]

T. Lehmann and J. Loeckx. Obscure, a specification language for abstract data types. Report a 19/90, Univ. Saarbr{ücken, 1990.

[LLFRA93]

R. Loogen, F. Lopez Fraguas, and M. Rodr\'\iguez Artalejo. A demand driven computation strategy for lazy narrowing. In Proc. of the 5th International Symposium on Programming Language Implementation and Logic Programming, pages 184-200. Springer LNCS 714, 1993.

[Llo87]

J.W. Lloyd. Foundations of Logic Programming. Springer, second, extended edition, 1987.

[Llo94a]

J.W. Lloyd. Combining functional and logic programming languages. In Proc. of the International Logic Programming Symposium, pages 43-57, 1994.

[Llo94b]

J.W. Lloyd. Combining functional and logic programming languages. Technical report cstr-94-07, Univ. Bristol, 1994. To appear in Proc. ILPS'94.

[Llo94c]

J.W. Lloyd. Practical advantages of declarative programming. Technical report cstr-94-06, Univ. of Bristol, 1994. To appear in the 1994 Joint Conference on Declarative Programming GULP-PRODE'94.

[Llo95]

J.W. Lloyd. Declarative programming in escher. Technical report cstr-95-013, University of Bristol, 1995.

[Llo98]

J.W. Lloyd. Interaction and concurrency in a declarative programming language. Technical report, University of Bristol, 1998.

[Llo99]

J. Lloyd. Programming in an integrated functional and logic language. Journal of Functional and Logic Programming, (3):1-49, 1999.

[LLOW91]

C. Lamb, G. Landis, J. Orenstein, and D. Weinreb. The objectstore database system. Communications of the ACM, 34(10):50-63, 1991.

[LM84]

J.-L. Lassez and M.J. Maher. Closures and fairness in the semantics of programming logic. Theoretical Computer Science, 29:167-184, 1984.

[LM90]

G. Longo and E. Moggi. Constructive natural deduction and its ``$ømega$-set'' interpretation (revised version). Report liens-90-21, LIENS, Paris, 1990.

[LMM88]

J.-L. Lassez, M.J. Maher, and K. Marriott. Unification revisited. In J. Minker, editor, Foundations of Deductive Databases and Logic Programming, pages 587-625. Morgan Kaufman, Los Altos, 1988.

[LMM95]

E. Lamma, P. Mello, and M. Milano. A meta constraint logic programming scheme. Deis technical report deis-lia-95-005, Univ. Bologna, 1995.

[LMM96]

E. Lamma, M. Milano, and P. Mello. A multi-level clp architecture for consistency techniques. In Constraint'96 Workshop (in conjunction with FLAIRS'96), 1996.

[LMO92]

G. Lindstrom, J. Maluszynski, and T. Ogi. Our lips are sealed: Interfacing functional and logic programming systems. In Proc. of the 4th International Symposium on Programming Language Implementation and Logic Programming, pages 428-442. Springer LNCS 631, 1992.

[LMS94]

H. Lock, A. Mück, and T. Streicher. A tiny constraint functional logic programming language and its continuation semantics. In Proc.\ 5th European Symposium on Programming, pages 439-453. Springer LNCS 788, 1994.

[LN92]

J. Leach and S. Nieva. Foundation of a theorem prover for functional and mathematical uses. UCM Madrid, 1992.

[LO87]

T.G. Lindholm and R.A. O'Keefe. Efficient implementation of a defensible semantics for dynamic prolog code. In Proc. Fourth International Conference on Logic Programming (Melbourne), pages 21-39. MIT Press, 1987.

[LO94]

K. Läufer and M. Odersky. Polymorphic type inference and abstract data types. ACM Transactions on Programming Languages and Systems, 16(5):1411-1430, 1994.

[Loc91]

H.C.R. Lock. A systematic method for designing abstract narrowing machines. In J. Darlington and R. Dietrich, editors, Workshop on Declarative Programming, pages 188-203. Springer, Workshops in Computing, 1991.

[Loc92]

H.C.R. Lock. The Implementation of Functional Logic Programming Languages. PhD thesis, Technical University of Berlin, 1992. Also available as GMD Report 208, Oldenbourg Verlag, M{ünchen.

[Loe90]

J. Loeckx. Obscure: Eine spezifikations- und verifikationsumgebung. In H. Kersten, editor, Sichere Software, pages 268-279, 1990.

[Loo91]

R. Loogen. From reduction machines to narrowing machines. In Proc. of the TAPSOFT '91, pages 438-457. Springer LNCS 494, 1991.

[Loo93a]

R. Loogen. Funktional-logische Programmiersprachen - Semantik und Implementierung. PhD thesis, RWTH Aachen, 1993. Habiliationsschrift.

[Loo93b]

R. Loogen. Relating the implementation techniques of functional and functional logic languages. New Generation Computing, 11:179-215, 1993.

[Lov78]

D.W. Loveland. Automated Theorem Proving: A Logical Basis. North-Holland, Amsterdam, 1978.

[lp888]

Proc. 5th Conference on Logic Programming & 5th Symposium on Logic Programming (Seattle). MIT Press, 1988.

[LPJ94]

J. Launchbury and S.L. Peyton Jones. Lazy functional state threads. In ACM SIGPLAN'94 Conference on Programming Language Design and Implementation, pages 24-35. ACM SIGPLAN Notices Vol. 29 No. 6, 1994.

[LPW92]

T. Le Provost and M. Wallace. Generalized constraint propagation over the clp scheme. Technical report ecrc-92-1, ECRC, 1992. To appear in Journal of Logic Programming.

[LR91]

T.K. Lakshman and U.S. Reddy. Typed prolog: A semantic reconstruction of the mycroft-o'keefe type system. In Proc. International Logic Programming Symposium. MIT Press, 1991.

[LR95a]

D.A. Ladd and J.C. Ramming. Programming the web: An application-oriented language for hypermedia services. In 4th International World Wide Web Conference, 1995.

[LR95b]

S. Limet and P. Réty. Directed narrowing: an optimization that more often terminates. Research report lifo 95-7, Univ. Orléans, 1995.

[LR98]

S. Limet and P. Réty. Solving disequations modulo some class of rewrite systems. In 9th International Conference on Rewriting Techniques and Applications (RTA'98), pages 121-135. Springer LNCS 1379, 1998.

[LS88a]

A. Lakhotia and L. Sterling. How to control unfolding when specializing interpreters, 1988.

[LS88b]

G. Levi and G. Sardu. Partial evaluation of metaprograms in a ``multiple worlds'' logic language. New Generation Computing, 6:227-247, 1988.

[LS88c]

B. Liskov and L. Shrira. Promises: Linguistic support for efficient asynchronous procedure calls in distributed systems. In Proc. SIGPLAN'88 Conference on Programming Language Design and Implementation, pages 260-267. ACM SIGPLAN Notices 23(7), 1988.

[LS90]

P. Lim and P.J. Stuckey. A constraint logic programming shell. In Proc. of the 2nd Int. Workshop on Programming Language Implementation and Logic Programming, pages 75-88. Springer LNCS 456, 1990.

[LS91]

J.W. Lloyd and J.C. Shepherdson. Partial evaluation in logic programming. Journal of Logic Programming, 11:217-242, 1991.

[LS92]

C. Lor\'\ia-Sáenz. Synthesis of narrowing programs. In Proc. Int. Workshop on Logic Program Synthesis and Transformation (LOPSTR'92), pages 30-45. Springer Workshops in Computing Series, 1992.

[LS96]

M. Leuschel and M.H. Sørensen. Redundant argument filtering of logic programs. In Proc. LOPSTR'96, pages 83-103. Springer LNCS 1207, 1996.

[LSR87]

M.E.S. Loomis, A.V. Shah, and J.E. Rumbaugh. An object modelling technique for conceptual design. In Proc. ECOOP'87, pages 325-335, 1987.

[LST87]

J.W. Lloyd, E.A. Sonenberg, and R.W. Topor. Integrity constraint checking in stratified databases. Journal of Logic Programming, 4:331-343, 1987.

[LSW83]

J. Ludewig, U. Schult, and F. Wankmueller. Chasing the busy-beaver - notes and observations on a competition to find the 5-state busy beaver. Report nr. 159, Univ. Dortmund, 1983.

[LT85]

J.W. Lloyd and R.W. Topor. A basis for deductive database systems. Journal of Logic Programming, 2:93-109, 1985.

[LT86]

J.W. Lloyd and R.W. Topor. A basis for deductive database systems ii. Journal of Logic Programming, 3:55-67, 1986.

[Luc95]

S. Lucas. Fundamentals of context-sensitive rewriting. In Proc. SOFSEM'95: Theory and Practice of Informatics, pages 405-412. Springer LNCS 1012, 1995.

[Luc96a]

S. Lucas. Context-sensitive computations in confluent programs. In Proc. PLILP'96, pages 408-422. Springer LNCS 1140, 1996.

[Luc96b]

S. Lucas. Termination of context-sensitive rewriting by rewriting. In Proc. ICALP'96, pages 122-133. Springer LNCS 1099, 1996.

[Luc97a]

S. Lucas. Efficient strong sequentiality using replacement restrictions. In Proc. SOFSEM'97: Theory and Practice of Informatics, pages 489-496. Springer LNCS 1338, 1997.

[Luc97b]

S. Lucas. Needed reductions with context-sensitive rewriting. In Proc. Algebraic and Logic Programming (ALP'97-HOA'97), pages 129-143. Springer LNCS 1298, 1997.

[Luc97c]

S. Lucas. Transformations for efficient evaluations in functional programming. In Proc. PLILP'97, pages 127-141. Springer LNCS 1292, 1997.

[Luc98a]

S. Lucas. Context-sensitive computations in functional and functional logic programs. Journal of Functional and Logic Programming, 1998(1), 1998.

[Luc98b]

S. Lucas. Root-neededness and approximations of neededness. Information Processing Letters, 67(5):245-254, 1998.

[L{üt87]

S. Lüttringhaus. Deduktive datenbanksysteme: Theoretische und praktische aspekte. Bericht nr. 231, Univ. Dortmund, 1987.

[Lux99]

W. Lux. Implementing encapsulated search for a lazy functional logic language. In Proc. 4th Fuji International Symposium on Functional and Logic Programming (FLOPS'99), pages 100-113. Springer LNCS 1722, 1999.

[LW91]

R. Loogen and S. Winkler. Dynamic detection of determinism in functional logic languages. In Proc. of the 3rd Int. Symposium on Programming Language Implementation and Logic Programming, pages 335-346. Springer LNCS 528, 1991. Extended version to appear in Theoretical Computer Science, 1995.

[LW94a]

K.-K. Lau and G.A. Wiggins. Synthesis of logic programs. Tutorial notes presented at ICLP'94, 1994.

[LW94b]

B.H. Liskov and J.M. Wing. A behavioral notion of subtyping. ACM Transactions on Programming Languages and Systems, 16(6):1811-1841, 1994.

[LW95]

R. Loogen and S. Winkler. Dynamic detection of determinism in functional logic languages. Theoretical Computer Science 142, pages 59-87, 1995.

[LW99]

C. Lüth and B. Wolff. Functional design and implementation of graphical user interfaces for theorem provers. Journal of Functional Programming, 9(2):167-189, 1999.

[LY97]

T. Lindholm and F. Yellin. The Java Virtual Machine Specification. Addison-Wesley, 1997.

[Mac77]

A.K. Mackworth. Consistency in networks of relations. Artificial Intelligence, 8:99-118, 1977.

[Mac84]

D. MacQueen. Modules for standard ml. In Proc. of the ACM Symposium on LISP and Functional Programming, pages 198-207, 1984.

[Mah86]

M.J. Maher. Equivalences of logic programs. In Proc. Third International Conference on Logic Programming (London), pages 410-424. Springer LNCS 225, 1986.

[Mah87]

M.J. Maher. Logic semantics for a class of committed-choice programs. In Proc. Fourth International Conference on Logic Programming (Melbourne), pages 858-876. MIT Press, 1987.

[Mal98]

M.A. Malik. Evolution of the high level programming languages: A critical perspective. ACM SIGPLAN Notices, 33(12):72-80, 1998.

[Man91]

A.V. Mantsivoda. Flang: a functional-logic language. In Proc.\ Int.\ Workshop on Processing Declarative Knowledge, pages 257-270. Springer LNAI 567, 1991.

[Man93a]

L. Mandel. The semantics of the untyped constrained lambda calculus. Technical report, LMU M{ünchen, 1993.

[Man93b]

A.V. Mantsivoda. Avoiding trailing in logic programming. Technical report no. 15-07/93, Irkutsk University, 1993.

[Man93c]

A.V. Mantsivoda. Disjunctive constraints and finite domains. Technical report no. 25-07/93, Irkutsk University, 1993.

[Man93d]

A.V. Mantsivoda. Flang and its implementation. In Proc. of the 5th International Symposium on Programming Language Implementation and Logic Programming, pages 151-166. Springer LNCS 714, 1993.

[Mar86]

U. Martin. Unification in boolean rings and unquantified formulae of first order predicate calculus. Technical report umcs-86-11-2, Univ. of Manchester, 1986.

[Mar87]

S. Martini. An interval model for second order lambda calculus. In Category Theory and Computer Science, pages 219-237. Springer LNCS 283, 1987.

[Mar88]

S. Martini. Bounded quantifiers have interval models. In Proc. of the ACM Symposium on LISP and Functional Programming, 1988.

[Mar91]

L. Maranget. Optimal derivations in weak lambda-calculi and in orthogonal terms rewriting systems. In Proc. 18th ACM Symposium on Principles of Programming Languages, pages 255-269, 1991.

[Mar97]

K. Marriott. Algebraic and logical semantics for clp languages with dynamic scheduling. Journal of Logic Programming, 32(1):71-84, 1997.

[Mau91]

M. Mauny. Functional Programming using CAML Light. INRIA, 1991.

[Maz97]

N. Mazur. Declarative i/o within a functional logic language: determinism analysis. Master's thesis, K.U. Leuven, 1997.

[MB88]

J.W. Mills and K.A. Buettner. Assertive demons. In Proc. 5th Conference on Logic Programming & 5th Symposium on Logic Programming (Seattle), pages 1403-1414. MIT Press, 1988.

[MB92]

T. Mogensen and A. Bondorf. Logimix: A self-applicable partial evaluator for prolog. In Proc. Int. Workshop on Logic Program Synthesis and Transformation (LOPSTR'92), pages 214-227. Springer Workshops in Computing Series, 1992.

[MBL97]

A.C. Myers, J.A. Bank, and B. Liskov. Parameterized types for java. In Proc.\ of the 24th ACM Symposium on Principles of Programming Languages (Paris), pages 132-145, 1997.

[McC84]

N. McCracken. The typechecking of programs with implicit type structure. In Int. Symposium on Semantics of Data Types, pages 301-315. Springer LNCS 173, 1984.

[McC93]

F.G. McCabe. An introduction to l&o. In K.R. Apt, J.W. de Bakker, and J.J.M.M. Rutten, editors, Logic programming languages: constraints, functions, and objects, pages 148-184. MIT Press, 1993.

[MD89]

A. Mariën and B. Demoen. On the management of choicepoint and environment frames in the wam. In Proc. of the 1989 North American Conference on Logic Programming, pages 1030-1047. MIT Press, 1989.

[MDdV88]

M. Meier, P. Dufresne, and D.H. de Villeneuve. Sepia. Report tr-lp-36, ECRC, 1988.

[MDR93]

S. Muggleton and L. De Raedt. Inductive logic programming: Theory and methods. Submitted to the Journal of Logic Programming, 1993.

[Mei88]

M. Meier. Benchmarking of prolog procedures for indexing purposes. In Proc. FGCS'88, 1988.

[Mei90]

K. Meinke. Universal algebra in higher types. To appear in Theoretical Computer Science, 1990.

[Mei91]

M. Meier. Recursion vs. iteration in prolog. In Proc. International Conference on Logic Programming, pages 157-169. MIT Press, 1991.

[Mei94]

M. Meier. Better late than never. In E. Tick and G. Succi, editors, Implementations of Logic Programming Systems, pages 151-165. Kluwer Academic Publishers, 1994.

[Mei00]

E. Meijer. Server side web scripting in haskell. Journal of Functional Programming, 10(1):1-18, 2000.

[Mel82]

C.S. Mellish. An alternative to structure sharing in the implementation of a prolog interpreter. In K.L. Clark and S.-A. {Tärnlund}, editors, Logic Programming, pages 99-106. Academic Press, 1982.

[Mel85]

C.S. Mellish. Some global optimizations for a prolog compiler. Journal of Logic Programming (1), pages 43-66, 1985.

[Mel86]

C.S. Mellish. Abstract interpretation of prolog programs. In Proc. Third International Conference on Logic Programming (London), pages 463-474. Springer LNCS 225, 1986.

[Mel87]

C.S. Mellish. Abstract interpretation of prolog programs. In S. Abramsky and C. Hankin, editors, Abstract Interpretation of Declarative Languages, pages 181-198. Ellis Horwood, 1987.

[Mel88]

F. Mellender. An integration of logic and object-oriented programming. SIGPLAN Notices, 23(10):181-185, 1988.

[Mey88]

B. Meyer. Object-oriented Software Construction. Prentice Hall, 1988.

[Mey90]

B. Meyer. Lessons from the design of the eiffel libraries. Communications of the ACM, 33(9):68-88, 1990.

[MGdlBH94]

K. Marriott, M.J. Garcia de la Banda, and M. Hermenegildo. Analyzing logic programs with dynamic scheduling. In Proc. 21st ACM Symposium on Principles of Programming Languages, pages 240-253, Portland, 1994.

[MGS87]

J. Meseguer, J.A. Goguen, and G. Smolka. Order-sorted unification. Report csli-87-86, SRI International, Stanford, 1987.

[MGS89]

J. Meseguer, J.A. Goguen, and G. Smolka. Order-sorted unification. Journal of Symbolic Computation, 8:383-413, 1989.

[MH86]

R. Mohr and T.C. Henderson. Arc and path consistency revisited. Artificial Intelligence, 28:225-233, 1986.

[MH88]

J.C. Mitchell and R. Harper. The essence of ml. In Proc. of the 15th ACM Symposium on Principles of Programming Languages, pages 28-46, San Diego, 1988.

[MH89a]

K. Muthukumar and M. Hermenegildo. Complete and efficient methods for supporting side-effects in independent/restricted and-parallelism. In Proc. Sixth International Conference on Logic Programming (Lisboa). MIT Press, 1989.

[MH89b]

K. Muthukumar and M. Hermenegildo. Determination of variable dependence information through abstract interpretation. In Proc. of the 1989 North American Conference on Logic Programming, pages 166-185, 1989.

[MH90]

K. Muthukumar and M.V. Hermenegildo. The cdg, udg, and mel methods for automatic compile-time parallelization of logic programs for independent and-parallelism. In Proc. Seventh International Conference on Logic Programming. MIT Press, 1990.

[MH91a]

A. Middeldorp and E. Hamoen. Counterexamples to completeness results for basic narrowing. CWI Amsterdam, 1991.

[MH91b]

K. Muthukumar and M. Hermenegildo. Combined determination of sharing and freeness of program variables through abstract interpretation. In Proc. International Conference on Logic Programming, pages 49-63. MIT Press, 1991.

[MH91c]

K. Muthukumar and M. Hermenegildo. Compile-time derivation of variable dependency using abstract interpretation. To appear in Journal of Logic Programming, 1991.

[MH92a]

A. Middeldorp and E. Hamoen. Counterexamples to completeness results for basic narrowing. In Proc. of the 3rd International Conference on Algebraic and Logic Programming, pages 244-258. Springer LNCS 632, 1992.

[MH92b]

K. Muthukumar and M. Hermenegildo. Compile-time derivation of variable dependency using abstract interpretation. Journal of Logic Programming, 13(2-3):315-347, 1992.

[MH94]

A. Middeldorp and E. Hamoen. Completeness results for basic narrowing. Applicable Algebra in Engineering, Communication and Computing, 5:213-253, 1994.

[Mid97]

A. Middeldorp. Call by need computations to root-stable form. In Proc.\ of the 24th ACM Symposium on Principles of Programming Languages (Paris), pages 94-105, 1997.

[Mil78]

R. Milner. A theory of type polymorphism in programming. Journal of Computer and System Sciences, 17:348-375, 1978.

[Mil84]

R. Milner. A proposal for standard ml. In Conference Record of the 1984 ACM Symposium On Lisp and Functional Programming, pages 184-197, Austin, Texas, 1984.

[Mil86]

D. Miller. A theory of modules for logic programming. In Proc. IEEE Internat. Symposium on Logic Programming, pages 106-114, Salt Lake City, 1986.

[Mil89a]

D. Miller. A logical analysis of modules in logic programming. Journal of Logic Programming, pages 79-108, 1989.

[Mil89b]

J.W. Mills. A high-performance low risc machine for logic programming. Journal of Logic Programming (6), pages 179-212, 1989.

[Mil90a]

D. Miller. A logic programming language with lambda abstraction, function variables and simple unification. Technical report ms-cis-90-54, Univ. of Pennsylvania, 1990.

[Mil90b]

R. Milner. Functions as processes. In Proc. ICALP'90, pages 167-180. Springer LNCS 443, 1990.

[Mil91a]

D. Miller. Abstract syntax and logic programming. In Proc. of the Second Russian Conference on Logic Programming, pages 322-337. Springer LNAI 592, 1991.

[Mil91b]

D. Miller. Unification of simply typed lambda-terms as logic programming. In Proc. Int. Conference on Logic Programming (Paris), pages 255-269. MIT Press, 1991.

[Mil91c]

R. Milner. Polyadic $π$-calculus. Slides presented at TAPSOFT'91, 1991.

[Mil93]

R. Milner. Elements of interaction. Communications of the ACM, 36(1):78-89, 1993.

[Mil94]

D. Miller. Specifications using multiple-conclusion logic programs. Slides presented at PLILP'94, 1994.

[Mil95]

H. Millroth. Performance models in parallel programming. Slides presented at ILPS'95, 1995.

[Min89]

J. Minker. Toward a foundation of disjunctive logic programming. In Proc. of the 1989 North American Conference on Logic Programming, pages 1215-1235. MIT Press, 1989.

[Mis84]

P. Mishra. Towards a theory of types in prolog. In Proc. IEEE Internat. Symposium on Logic Programming, pages 289-298, Atlantic City, 1984.

[Mit84]

J.C. Mitchell. Coercion and type inference (summary). In Proc. 11th POPL, pages 175-185, 1984.

[MJMB89]

A. Marien, G. Janssens, A. Mulkers, and M. Bruynooghe. The impact of abstract interpretation: an experiment in code generation. In Proc. Sixth International Conference on Logic Programming (Lisboa), pages 33-47. MIT Press, 1989.

[MJT91]

L. Matyska, A. Jergova, and D. Toman. Register allocation in wam. In Proc. International Conference on Logic Programming, pages 142-156. MIT Press, 1991.

[MK88]

G. Moerkotte and S. Karl. Efficient consistency control in deductive databases. In 2nd Int. Conf. on Database Theory, pages 118-128. Springer LNCS 326, 1988.

[MK98]

P.-E. Moreau and H. Kirchner. A compiler for rewrite programs in associative-commutative theories. In Principles of Declarative Programming (Proc. Joint International Symposium PLILP/ALP'98), pages 230-249. Springer LNCS 1490, 1998.

[MKLR90a]

J.J. Moreno-Navarro, H. Kuchen, R. Loogen, and M. Rodr\'\iguez-Artalejo. Lazy narrowing in a graph machine. In Proc. Second International Conference on Algebraic and Logic Programming, pages 298-317. Springer LNCS 463, 1990.

[MKLR90b]

J.J. Moreno-Navarro, H. Kuchen, R. Loogen, and M. Rodr\'\iguez-Artalejo. Lazy narrowing in a graph machine. Report no. 90-11, RWTH Aachen, 1990.

[ML75]

P. Martin-Löf. An intuitionistic theory of types: Predicative part. In Logic Colloquium '73, pages 73-118. North-Holland, 1975.

[MM82]

A. Martelli and U. Montanari. An efficient unification algorithm. ACM Transactions on Programming Languages and Systems, 4(2):258-282, 1982.

[MM84]

B. Mahr and J.A. Makowsky. Characterizing specification languages which admit initial semantics. Theoretical Computer Science 31, pages 49-59, 1984.

[MMP88]

P. Mancarella, S. Martini, and D. Pedreschi. Complete logic programs with domain-closure axiom. Journal of Logic Programming, 5:263-276, 1988.

[MMR86]

A. Martelli, C. Moiso, and G.F. Rossi. An algorithm for unification in equational theories. In Proc. IEEE Internat. Symposium on Logic Programming, pages 180-186, Salt Lake City, 1986.

[MMTN91]

G. Mansfield, N. Miyake, A. Togashi, and S. Noguchi. Amlog-e: A new approach towards amalgamation. In Proc. International Conference on Logic Programming, pages 364-378. MIT Press, 1991.

[MN86]

D.A. Miller and G. Nadathur. Higher-order logic programming. In Proc. Third International Conference on Logic Programming (London), pages 448-462. Springer LNCS 225, 1986.

[MN87]

D. Miller and G. Nadathur. A logic programming approach to manipulating formulas and programs. In Proc. 4th IEEE Internat. Symposium on Logic Programming, pages 379-388, San Francisco, 1987.

[MN89a]

J. Maluszynski and T. Näslund. Fail substitutions for negation as failure. In Proc. of the 1989 North American Conference on Logic Programming, pages 461-476. MIT Press, 1989.

[MN89b]

U. Martin and T. Nipkow. Boolean unification - the story so far. J. Symbolic Computation, 7:275-293, 1989.

[MN90]

K.A. Massmann and R. Neerfeld. Effizientes pattern matching in termen. Diplomarbeit, Univ. Dortmund, 1990.

[MN94a]

R. Mayr and T. Nipkow. Higher-order rewrite systems and their confluence. Report tum-i9433, TU M{ünchen, 1994.

[MN94b]

J.J. Moreno-Navarro. Default rules: An extension of constructive negation for narrowing-based languages. In Proc. Eleventh International Conference on Logic Programming, pages 535-549. MIT Press, 1994.

[MN95]

J.J. Moreno-Navarro. Tuple inheritance: A new kind of inheritance for (constraint) logic programming. Technical report, U.P. Madrid, 1995.

[MN96]

J.J. Moreno-Navarro. Extending constructive negation for partial functions in lazy functional-logic languages. In Proc. 5th International Workshop on Extensions of Logic Programming, pages 213-227. Springer LNAI 1050, 1996.

[MN98]

R. Mayr and T. Nipkow. Higher-order rewrite systems and their confluence. Theoretical Computer Science 192, pages 3-29, 1998.

[MNKMC+93]

J.J. Moreno-Navarro, H. Kuchen, J. Marino-Carballo, S. Winkler, and W. Hans. Efficient lazy narrowing using demandedness analysis. In Proc. of the 5th International Symposium on Programming Language Implementation and Logic Programming, pages 167-183. Springer LNCS 714, 1993.

[MO84]

A. Mycroft and R.A. O'Keefe. A polymorphic type system for prolog. Artificial Intelligence, 23:295-307, 1984.

[MO98]

A. Middeldorp and S. Okui. A deterministic lazy narrowing calculus. Journal of Symbolic Computation, 25(6):733-757, 1998.

[Moh95a]

M. Mohnen. Efficient compile-time garbage collection for arbitrary data structures. Technical report 95-8, RWTH Aachen, 1995.

[Moh95b]

M. Mohnen. Functional specification of imperative programs: An alternative point of view of functional languages. Technical report 95-9, RWTH Aachen, 1995.

[MOI95a]

A. Middeldorp, S. Okui, and T. Ida. Lazy narrowing: Strong completeness and eager variable elimination. In Proc. CAAP'95, pages 394-408. Springer LNCS 915, 1995.

[MOI95b]

A. Middeldorp, S. Okui, and T. Ida. Lazy narrowing: Strong completeness and eager variable elimination. Technical report, Univ. of Tsukuba, 1995.

[MOI96]

A. Middeldorp, S. Okui, and T. Ida. Lazy narrowing: Strong completeness and eager variable elimination. Theoretical Computer Science, 167(1,2):95-130, 1996.

[MOM93]

N. Marti-Oliet and J. Meseguer. Rewriting logic as a logical and semantic framework. Technical report, SRI International, 1993.

[Mon93]

B. Monsuez. Polymorphic types and widening operators. In Third International Workshop on Static Analysis (WSA'93), pages 267-281. Springer LNCS 724, 1993.

[Mor88]

J. Morris. Algebraic Operational Semantics for Modula-2. PhD thesis, Univ. of Michigan, 1988.

[Mos82]

C. Moss. How to define a language using prolog. In ACM Conf. Rec. of the 1982 ACM Symp. on Lisp and Functional Programming, pages 67-73, 1982.

[Mos86]

C. Moss. Cut & paste - defining the impure primitives of prolog. In Proc. Third International Conference on Logic Programming (London), pages 686-694. Springer LNCS 225, 1986.

[Mos88a]

P.D. Mosses. Abstract data types as lattices. Aarhus Univ., 1988.

[Mos88b]

P.D. Mosses. The modularity of action semantics. Report dami ir-75, Aarhus Univ., 1988.

[Mos89a]

P.D. Mosses. Unified algebras and action semantics. In Proc. STACS'89. Springer LNCS, 1989.

[Mos89b]

P.D. Mosses. Unified algebras and institutions. In Proc. LICS'89, 1989.

[Mos89c]

P.D. Mosses. Unified algebras and modules. In Proc. POPL'89, 1989.

[Mos91]

P.D. Mosses. An introduction to action semantics. Daimi pb-370, Aarhus Univ., 1991.

[Mos94]

C. Moss. Prolog++: the power of object-oriented and logic programming. International series in logic programming. Addison-Wesley, Wokingham, 1994.

[Mos95]

C. Moss. Objects and logic. Slides presented at ILPS'95, 1995.

[MP85]

J.C. Mitchell and G.D. Plotkin. Abstract types have existential type. In Proc. 12th POPL, pages 37-51, 1985.

[MP88]

P. Mancarella and D. Pedreschi. An algebra of logic programs. In Proc. 5th Conference on Logic Programming & 5th Symposium on Logic Programming (Seattle), pages 1006-1023, 1988.

[MP92a]

A. Mantsivoda and V. Petukhin. Compiling flang. In 4th Int. Conference on Compiler Construction, pages 297-311. Springer LNCS 641, 1992.

[MP92b]

D.E. Monarchi and G.I. Puhr. A research typology for object-oriented analysis and design. Communications of the ACM, 35(9):35-47, 1992.

[MPS84]

D. MacQueen, G. Plotkin, and R. Sethi. An ideal model for recursive polymorphic types. In Proc. 11th Annual Symposium on Principles of Programming Languages, pages 165-174, 1984.

[MPW92]

R. Milner, J. Parrow, and D. Walker. A calculus of mobile processes, parts i and ii. Information and Computation, 100:1-77, 1992.

[MR86]

A. Martelli and G. Rossi. On the semantics of logic programming languages. In Proc. Third International Conference on Logic Programming (London), pages 327-334. Springer LNCS 225, 1986.

[MR88]

A. Martelli and G.F. Rossi. Enhancing prolog to support prolog programming environments. In Proc. ESOP'88, pages 317-327. Springer LNCS 300, 1988.

[MR89]

J.J. Moreno-Navarro and M. Rodr\'\iguez-Artalejo. Logic programming with functions and predicates: The language babel. Technical report dia/89/3, Universidad Complutense, Madrid, 1989.

[MR92]

J.J. Moreno-Navarro and M. Rodr\'\iguez-Artalejo. Logic programming with functions and predicates: The language babel. Journal of Logic Programming, 12:191-223, 1992.

[MRM89]

A. Martelli, G.F. Rossi, and C. Moiso. Lazy unification algorithms for canonical rewrite systems. In Hassan A{\"\i}t-Kaci and Maurice Nivat, editors, Resolution of Equations in Algebraic Structures, Volume 2, Rewriting Techniques, chapter 8, pages 245-274. Academic Press, New York, 1989.

[MRNN]

P. Mishra and U.S. Reddy. Declaration-free type checking. Univ. of Utah, NN.

[MRS96]

E. Monfroy, M. Rusinowitch, and R. Schott. Implementing non-linear constraints with cooperative solvers. In Proc. ACM Symposium on Applied Computing (SAC'96), pages 63-72. ACM Press, 1996.

[MS88a]

K. Marriott and H. Søndergaard. Bottom-up abstract interpretation of logic programs. In Proc. 5th Conference on Logic Programming & 5th Symposium on Logic Programming (Seattle), pages 733-748, 1988.

[MS88b]

K. Marriott and H. Søndergaard. Semantics-based dataflow analysis of logic programs. Technical report 88/27, Univ. of Melbourne, 1988.

[MS89a]

K. Marriott and H. Søndergaard. Bottom-up dataflow analysis of normal logic programs. Report rc 14858, IBM Research Division, 1989.

[MS89b]

K. Marriott and H. Søndergaard. On prolog and the occur check problem, 1989. Internal note.

[MS90]

K. Marriott and H. Søndergaard. Analysis of constraint logic programs. In Proc. of the 1990 North American Conference on Logic Programming, pages 531-547. MIT Press, 1990.

[MS93a]

K. Marriott and H. Søndergaard. Precise and efficient groundness analysis for logic programs. Technical report 93/7, Univ. of Melbourne, 1993.

[MS93b]

K. Marriott and P.J. Stuckey. The 3 r's of optimizing constraint logic programs: Refinement, removal and reordering. In Proc. POPL'93, pages 334-344, 1993.

[MS96]

M. Müller and G. Smolka. Oz: Nebenläufige programmierung mit constraints. KI-K{ünstliche Intelligenz, Themenheft logische Programmierung, pages 55-61, 1996.

[MSD90]

K. Marriott, H. Søndergaard, and P. Dart. A characterization of non-floundering logic programs. In Proc. of the 1990 North American Conference on Logic Programming, pages 661-680. MIT Press, 1990.

[MSJ92]

K. Marriott, H. Søndergaard, and N.D. Jones. Denotational abstract interpretation of logic programs. Technical report 92/20, Univ. of Melbourne, 1992. Also appeared in TOPLAS, 1994.

[MSJ94]

K. Marriott, H. Søndergaard, and N.D. Jones. Denotational abstract interpretation of logic programs. ACM Transactions on Programming Languages and Systems, 16(3):607-648, 1994.

[MSS86]

O. Maler, Z. Scherz, and E. Shapiro. A new approach for introducing prolog to naive users. In Proc. Third International Conference on Logic Programming (London), pages 544-551. Springer LNCS 225, 1986.

[MSS91]

V. Manca, A. Salibra, and G. Scollo. On the expressiveness of equational type logic. Memoranda informatica 90-39-rev., Univ. Twente, 1991.

[MSS95]

M. Mehl, R. Scheidhauer, and C. Schulte. An abstract machine for oz. In Proc. 7th International Symposium on Programming Languages, Implementations, Logics and Programs (PLILP'95), pages 151-168. Springer LNCS 982, 1995.

[MT90]

A. Middeldorp and Y. Toyama. Completeness of combinations of constructor systems. Draft, 1990.

[MT98]

C. Meinel and T. Theobald. Ordered binary decision diagrams and their significance in computer-aided design of vlsi circuits. EATCS Bulletin 64, pages 171-187, 1998.

[MTH90]

R. Milner, M. Tofte, and R. Harper. The Definition of Standard ML. MIT Press, 1990.

[MTS+85]

C. Mierowsky, S. Taylor, E. Shapiro, J. Levy, and M. Safra. The design and implementation of flat concurrent prolog. Report cs85-09, Weizmann Institute of Sciences, Rehovot, 1985.

[MTW88]

B. Möller, A. Tarlecki, and M. Wirsing. Algebraic specification with built-in domain constructions. In Proc. CAAP'88, pages 132-148. Springer LNCS 299, 1988.

[MU87]

H. Mannila and E. Ukkonen. Flow analysis of prolog programs. In Proc. 4th IEEE Internat. Symposium on Logic Programming, pages 205-214, San Francisco, 1987.

[M{üc88]

A. Mück. Spezifikation einer abstrakten maschine für termersetzungssysteme. Diplomarbeit, Univ. Passau, 1988.

[M{üc90]

A. Mück. Compilation of narrowing. In Proc. of the 2nd Int. Workshop on Programming Language Implementation and Logic Programming, pages 16-29. Springer LNCS 456, 1990.

[M{üc92]

A. Mück. Camel: An extension of the categorical abstract machine to compile functional/logic programs. In Proc. of the 4th International Symposium on Programming Language Implementation and Logic Programming, pages 341-354. Springer LNCS 631, 1992.

[M{üc93]

A. M{ück, editor. Proc. of the Second International Workshop on Functional/Logic Programming. LMU M{ünchen, Report 9311, 1993.

[M{ül93]

B. Müller. Is object-oriented programming structured programming?. ACM SIGPLAN Notices, 28(9):57-66, 1993.

[Mun92]

T. Munakata. Notes on implementing sets in prolog. Communications of the ACM, 35(3):112-120, 1992.

[MV95]

S. Maneth and H. Vogler. Calculi and efficiency measures for narrowing techniques. Technical report tud/fi95/13-november 1995, TU Dresden, 1995.

[MvV00]

E. Meijer and D. van Velzen. Haskell server pages: Functional programming and the battle for the middle tier. In Proc. ACM SIGPLAN Haskell Workshop, Montreal, 2000.

[MW88]

D. Maier and D.S. Warren. Computing with Logic - Logic Programming with Prolog. Benjamin/Cummings, 1988.

[MW96]

T. Müller and J. Würtz. A survey on finite domain programming in oz. Technical report, DFKI, 1996.

[MW97]

S. Marlow and P. Wadler. A practical subtyping system for erlang. In Proc. of the International Conference on Functional Programming (ICFP'97), pages 136-149. ACM SIGPLAN Notices Vol. 32, No. 8, 1997.

[MWB93a]

A. Mulkers, W. Winsborough, and M. Bruynooghe. A live-structure data-flow analysis for prolog: Design and evaluation. Technical report cw 166, K.U. Leuven, 1993.

[MWB93b]

A. Mulkers, W. Winsborough, and M. Bruynooghe. A live-structure data-flow analysis for prolog: Theory. Technical report cw 167, K.U. Leuven, 1993.

[MWB94]

A. Mulkers, W. Winsborough, and M. Bruynooghe. Live-structure dataflow analysis for prolog. ACM Transactions on Programming Languages and Systems, 16(2):205-258, 1994.

[Myc80]

A. Mycroft. The theory and practice of transforming call-by-need into call-by-value. In Proc. International Symposium on Programming, pages 269-281. Springer LNCS 83, 1980.

[Myc84]

A. Mycroft. Polymorphic type schemes and recursive definitions. In International Symposium on Programming, pages 217-228. Springer LNCS 167, 1984.

[Myc87]

A. Mycroft. Private communication, 1987.

[Nad87]

G. Nadathur. A Higher-Order Logic as the Basis for Logic Programming. PhD thesis, Univ. of Pennsylvania, 1987.

[Nai85a]

L. Naish. Automating control for logic programs. Journal of Logic Programming (3), pages 167-183, 1985.

[Nai85b]

L. Naish. Prolog control rules. In Proc. IJCAI'85, pages 720-722, 1985.

[Nai87a]

L. Naish. Negation and Control in Prolog. Springer LNCS 238, 1987.

[Nai87b]

L. Naish. Specification = program + types. In Proc.\ Foundations of Software Technology and Theoretical Computer Science, pages 326-339. Springer LNCS 287, 1987.

[Nai90]

L. Naish. Types and the intended meaning of logic programs. Technical report 90/4, Univ. of Melbourne, 1990.

[Nai91]

L. Naish. Adding equations to nu-prolog. In Proc. of the 3rd Int. Symposium on Programming Language Implementation and Logic Programming, pages 15-26. Springer LNCS 528, 1991.

[Nai92a]

L. Naish. Coroutining and the construction of terminating logic programs. Technical report 92/5, Univ. of Melbourne, 1992.

[Nai92b]

L. Naish. Declarative debugging of lazy functional programs. Technical report 92/6, Univ. of Melbourne, 1992.

[Nai95a]

L. Naish. Pruning in logic programming. Slides presented at ICLP'95, 1995.

[Nai95b]

L. Naish. Pruning in logic programming. Technical report 95/16, University of Melbourne, 1995.

[Nai96]

L. Naish. Higher-order logic programming in prolog. In Proc. JICSLP'96 Workshop on Multi-Paradigm Logic Programming, pages 167-176. TU Berlin, Technical Report No. 96-28, 1996.

[Nak86]

K. Nakamura. Control of logic program execution based on the functional relation. In Proc. Third International Conference on Logic Programming (London), pages 505-512. Springer LNCS 225, 1986.

[Nar89]

S. Narain. Optimization by non-deterministic, lazy rewriting. In Proc. of the Conference on Rewriting Techniques and Applications, pages 326-342. Springer LNCS 355, 1989.

[Nar90]

S. Narain. Lazy evaluation in logic programming. In Proc. 1990 Int. Conference on Computer Languages, pages 218-227, 1990.

[Nei86]

B. Neidecker. Ka-prolog. kap-maschine: Maschinenmodell und instruktionssatz. Technical report 19/86, Univ. Karlsruhe, 1986.

[Nei87]

B. Neidecker. Ka-prolog - entwurf eines compilierenden prolog-entwicklungssystems. Diplomarbeit, interner bericht 29/87, Univ. Karlsruhe, 1987.

[Ner92]

J.M. Nerson. Applying object-oriented analysis and design. Communications of the ACM, 35(9):63-74, 1992.

[Neu90]

U. Neumerkel. Extensible unification by metastructures. In Proc. META'90, 1990.

[Neu92]

G. Neugebauer. From horn clauses to first order logic: A graceful ascent. TH Darmstadt (submitted), 1992.

[NF94]

H. Nilsson and P. Fritzson. Algorithmic debugging for lazy functional languages. Journal of Functional Programming, 4(3):337-370, 1994.

[NGT92]

O. Nierstrasz, S. Gibbs, and D. Tsichritzis. Component-oriented software development. Communications of the ACM, 35(9):160-165, 1992.

[Nic82]

J.M. Nicolas. Logic for improving integrity checking in relational data bases. Acta Informatica, 18:227-253, 1982.

[Nie95]

R. Nieuwenhuis. On narrowing, refutation proofs and constraints. In Proc. RTA'95, pages 56-70. Springer LNCS 914, 1995.

[Nil83]

J.F. Nilsson. On the compilation of a domain-based prolog. In Proc. IFIP'83, pages 293-298. Elsevier Science Publishers, 1983.

[Nil84]

J.F. Nilsson. Formal vienna-definition-method models of prolog. In J.A. Campbell, editor, Implementations of Prolog, pages 281-308. Ellis Horwood, 1984.

[Nil88]

U. Nilsson. Towards a framework for the abstract interpretation of logic programs. In Proc. of the Workshop on Programming Language Implementation and Logic Programming, pages 68-82, Orléans, 1988. Springer LNCS 348.

[Nil89]

U. Nilsson. A Systematic Approach to Abstract Interpretation of Logic Programs. PhD thesis, Link{öping University, 1989.

[Nil90a]

J.F. Nilsson. Combinatory logic programming. In Proc. META'90, 1990.

[Nil90b]

U. Nilsson. Systematic semantic approximations of logic programs. In Proc. of the 2nd Int. Workshop on Programming Language Implementation and Logic Programming, pages 293-306. Springer LNCS 456, 1990.

[Nil90c]

U. Nilsson. Towards a methodology for the design of abstract machines of logic programming languages. Report lith-ida-r-90-12, Univ. Link{öping, 1990.

[Nip90]

T. Nipkow. Higher-order unification, polymorphism, and subsorts. In Proc. CTRS'90, 1990.

[Nip91a]

T. Nipkow. Higher-order critical pairs. Technical report no. 218, Univ. of Cambridge, 1991.

[Nip91b]

T. Nipkow. Higher-order critical pairs. In Proc.\ 6th IEEE Symp.\ Logic in Computer Science, pages 342-349. IEEE Press, 1991.

[Nip92]

T. Nipkow. Practical unification of higher-order patterns. TU M{ünchen, 1992.

[Nip93]

T. Nipkow. Orthogonal higher-order rewrite systems are confluent. In Proc. Typed Lambda Calculi and Applications, 1993.

[Nit95]

K. Nitta. Overview of a legal reasoning system: New helic-ii. Slides presented at ICLP'95, 1995.

[NJ89]

G. Nadathur and B. Jayaraman. Towards a wam model for $λ$prolog. In Proc. of the 1989 North American Conference on Logic Programming, pages 1180-1198. MIT Press, 1989.

[NJK95]

G. Nadathur, B. Jayaraman, and K. Kwon. Scoping constructs in logic programming: Implementation problems and their solution. Journal of Logic Programming, 25(2):119-161, 1995.

[NL95]

G. Nadathur and D.W. Loveland. Uniform proofs and disjunctive logic programming (extended abstract). In Proc. LICS'95, pages 148-155, 1995.

[NM88]

G. Nadathur and D. Miller. An overview of $λ$prolog. In Proc. 5th Conference on Logic Programming & 5th Symposium on Logic Programming (Seattle), pages 810-827. MIT Press, 1988.

[NM90]

G. Nadathur and D. Miller. Higher-order horn clauses. Journal of the ACM, 37(4):777-814, 1990.

[NM98]

G. Nadathur and D. Miller. Higher-order logic programming. In D.M. Gabbay, C.J. Hogger, and J.A. Robinson, editors, Handbook of Logic in Artificial Intelligence and Logic Programming, pages 499-590. Oxford University Press, 1998.

[NMI95]

K. Nakahara, A. Middeldorp, and T. Ida. A complete narrowing calculus for higher-order functional logic programming. In Proc. of the 7th International Symposium on Programming Languages, Implementations, Logics and Programs (PLILP'95), pages 97-114. Springer LNCS 982, 1995.

[NOR91]

M. Navarro, F. Orejas, and J.-L. Remy. Contextual rewriting as a sound and complete proof method for conditional log-specifications. submitted, 1991.

[N{ø}r99]

K. Nørmark. Programming world wide web pages in scheme. ACM SIGPLAN Notices, 34(12):37-46, 1999.

[Noy94]

J. Noye. To trim or not to trim?. In E. Tick and G. Succi, editors, Implementations of Logic Programming Systems, pages 167-183. Kluwer Academic Publishers, 1994.

[NP92]

G. Nadathur and F. Pfenning. The type system of a higher-order logic programming language. Report cs-1992-02, Duke University, 1992.

[NQ91]

T. Nipkow and Z. Qian. Modular higher-order e-unification. In Proc. RTA'91, 1991.

[NQ92]

T. Nipkow and Z. Qian. Reduction and unification in lambda calculi with subtypes. In Proc. CADE-11, pages 66-78. Springer LNAI 607, 1992.

[NRS87]

W. Nutt, P. Réty, and G. Smolka. Basic narrowing revisited. Seki report sr-87-07, FB Informatik, Univ. Kaiserslautern, 1987.

[NRS89]

W. Nutt, P. Réty, and G. Smolka. Basic narrowing revisited. Journal of Symbolic Computation, 7:295-317, 1989.

[NS90]

T. Nipkow and G. Snelting. Type classes and overloading resolution via order-sorted unification. Technical report no. 200, Univ. of Cambridge, 1990.

[NS91a]

B. Nebel and G. Smolka. Attributive description formalisms and the rest of the world. Research report rr-91-15, DFKI, 1991.

[NS91b]

T. Nipkow and G. Snelting. Type classes and overloading resolution via order-sorted unification. In Proc.\ 5th ACM Conf.\ Functional Programming Languages and Computer Architecture (FPCA'91), pages 1-14. Springer LNCS 523, 1991.

[NT90]

S. Nadjm-Tehrani. Debugging prolog programs declaratively. In Proc. META'90, 1990.

[OBF+85]

M. Opitz, M. Brockhaus, T. Frühwirth, E. Kühn, A. Krall, M. Kolarik, and F. Reichl. Vip - a prolog programming environment. Report vip tr 1802/85/1, TU Wien, 1985.

[O'D98]

M. O'Donnell. Equational logic programming. In D.M. Gabbay, C.J. Hogger, and J.A. Robinson, editors, Handbook of Logic in Artificial Intelligence and Logic Programming, pages 69-161. Oxford University Press, 1998.

[Ode98]

M. Odersky. Programming with variable functions. In Proc. of the International Conference on Functional Programming (ICFP'98), pages 105-116. ACM SIGPLAN Notices 34(1), 1998.

[OG89]

J.W. OToole and D.K. Gifford. Type reconstruction with first-class polymorphic values. In Proc. SIGPLAN'89 PLDI, 1989.

[Ohl92]

E. Ohlebusch. Combination of simplifying conditional term rewriting systems. Report no. 6, Univ. Bielefeld, 1992.

[Ohl94]

E. Ohlebusch. Modular Properties of Composable Term Rewriting Systems. PhD thesis, Univ. Bielefeld, 1994. Also available as Technical Report 94-01.

[Ohl99a]

E. Ohlebusch. Deterministic conditional rewrite systems. Technical report, Univ. Bielefeld, 1999.

[Ohl99b]

E. Ohlebusch. Transforming conditional rewrite system with extra variables into unconditional systems. In Proc.\ of the 6th International Conference on Logic for Programming and Automated Reasoning (LPAR'99), pages 111-130. Springer LNCS 1705, 1999.

[Oho95]

A. Ohori. A polymorphic record calculus and its compilation. ACM Transactions on Programming Languages and Systems, 17(6):844-895, 1995.

[OI92]

S. Okui and T. Ida. Lazy narrowing calculi. Report ise-tr-92-97, Univ. of Tsukuba, 1992.

[O'K87]

R.A. O'Keefe. Finite fixed-point problems. In Proc. Fourth International Conference on Logic Programming (Melbourne), pages 729-743. MIT Press, 1987.

[Oku96]

S. Okui. Lazy Narrowing Calculi. PhD thesis, Univ. Tsukuba, 1996.

[Opa92]

R. Opalla. Effizientes pattern-matching bei der implementierung logisch-funktionaler programmiersprachen. Diplomarbeit, Univ. Dortmund, 1992.

[Ous94]

J.K. Ousterhout. Tcl and the Tk toolkit. Addison Wesley, 1994.

[Ove92]

R. Overbeek. Investigating the fundamental mechanisms of life through analysis of genetic sequence data. Advanced Tutorial at JICSLP'92, 1992.

[OW84]

H.G. Oberhauser and R. Wilhelm. Flow analysis in combinator implementation of functional programming languages. Univ. Saarbr{ücken, 1984.

[OW97]

M. Odersky and P. Wadler. Pizza into java: Translating theory into practice. In Proc.\ of the 24th ACM Symposium on Principles of Programming Languages (Paris), pages 146-159, 1997.

[Pad87]

P. Padawitz. Strategy-controlled reduction and narrowing. In Proc. of the Conference on Rewriting Techniques and Applications, pages 242-255. Springer LNCS 256, 1987.

[Pad88a]

P. Padawitz. Computing in Horn Clause Theories, volume 16 of EATCS Monographs on Theoretical Computer Science. Springer, 1988.

[Pad88b]

P. Padawitz. Program construction and horn logic: Two examples. Report mip-8806, Univ. Passau, 1988.

[Pad91]

P. Padawitz. A functional compiler specification and its direct implementation into sml. Report mip-9105, Univ. Passau, 1991.

[Pad92a]

P. Padawitz. Expander user's manual. Technical report 444, Univ. Dortmund, 1992.

[Pad92b]

P. Padawitz. Generic induction proofs. Technical report 440, Univ. Dortmund, 1992.

[Pad92c]

P. Padawitz. Generic induction proofs. In Proc. of the 3rd Intern. Workshop on Conditional Term Rewriting Systems, pages 175-197. Springer LNCS 656, 1992.

[Pad93]

P. Padawitz. Expander system description and manual. Technical report, Univ. Dortmund, 1993.

[Pal94]

C. Palamidessi. Concurrent constraint programming. Slides presented at PLILP'94, 1994.

[Pal95]

J. Palsberg. Closure analysis in constraint form. ACM Transactions on Programming Languages and Systems, 17(1):47-62, 1995.

[Par88]

D.L. Parnas. Why engineers should not use artificial intelligence. INFOR, 26(4):234-246, 1988.

[Pau90]

L.C. Paulson. Isabelle: The next 700 theorem provers. In P. Odifreddi, editor, Logic and Computer Science, pages 361-386. Academic Press, 1990.

[PBB+82]

P. Pepper, M. Broy, F.L. Bauer, H. Partsch, W. Dosch, and M. Wirsing. Abstrakte datentypen: Die algebraische spezifikation von rechenstrukturen. Informatik-Spektrum, 5:107-119, 1982.

[PBW85]

E. Pittomvils, M. Bruynooghe, and Y.D. Willems. Towards a real-time garbage collector for prolog. In Proc. IEEE Internat. Symposium on Logic Programming, pages 185-198, Boston, 1985.

[PC88]

L.M. Pereira and M. Calejo. A framework for prolog debugging. In Proc. 5th Conference on Logic Programming & 5th Symposium on Logic Programming (Seattle), pages 481-495. MIT Press, 1988.

[Pea97]

J. Peterson et al. Haskell: A non-strict, purely functional language (version 1.4). Technical report, Yale University, 1997.

[Per86]

L.M. Pereira. Rational debugging in logic programming. In Proc. Third International Conference on Logic Programming (London), pages 203-210, 1986.

[Per87]

F. Pereira. C-Prolog User's Manual, Version 1.5. University of Edinburgh, 1987.

[Pet83]

G.E. Peterson. A technique for establishing completeness results in theorem proving with equality. SIAM J. of Computing, 12(1):82-100, 1983.

[Pfe88]

F. Pfenning. Partial polymorphic type inference and higher-order unification. In Proc. ACM Conference on Lisp and Functional Programming, 1988.

[Pfe92]

F. Pfenning, editor. Types in Logic Programming. MIT Press, 1992.

[Pfe95]

F. Pfenning. Structural cut elimination. In Proc. LICS'95, pages 156-166, 1995.

[PG97]

E. Pontelli and G. Gupta. Implementation mechanisms for dependent and-parallelism. In Proc.\ of the Fourteenth International Conference on Logic Programming (ICLP'97), pages 123-137. MIT Press, 1997.

[PH94]

A. Poetzsch-Heffter. Deriving partial correctness logics from evolving algebras. In 13th World Computer Congress 94, Volume 1, pages 434-439, 1994.

[PH95]

A. Poetzsch-Heffter. Interface specifications for program modules supporting selective updates and sharing and their use in correctness proofs. In GI-Fachtagung Softwaretechnik '95, Braunschweig, 1995.

[PIL90a]

Projektgruppe PILS. Abschlu\ssbericht der projektgruppe pils. Univ. Dortmund, 1990.

[PIL90b]

Projektgruppe PILS. Zwischenbericht der projektgruppe pils. Univ. Dortmund, 1990.

[Pit93]

M. Pittman. Lessons learned in managing object-oriented development. IEEE Software, pages 43-53, 1993.

[PJ87]

S.L. Peyton Jones. The Implementation of Functional Programming Languages. Prentice Hall, 1987.

[PJ92a]

M. Page-Jones. Comparing techniques by means of encapsulation and connascence. Communications of the ACM, 35(9):147-151, 1992.

[PJ92b]

S.L. Peyton Jones. Implementing lazy functional languages on stock hardware: the spineless tagless g-machine. Journal of Functional Programming, 2(2):127-202, 1992.

[PJ93]

J. Peterson and M.P. Jones. Implementing type classes. In Proc. of ACM SIGPLAN SYmposium on Programming Language Design and Implementation (PLDI'93), pages 227-236. ACM SIGPLAN Notices Vol. 28, No. 6, 1993.

[PJ96]

S.L. Peyton Jones. Compiling haskell by program transformation: A report from the trenches. In Proc. ESOP'96, pages 18-44. Springer LNCS 1058, 1996.

[PJGF96]

S.L. Peyton Jones, A. Gordon, and S. Finne. Concurrent haskell. In Proc. 23rd ACM Symposium on Principles of Programming Languages (POPL'96), pages 295-308. ACM Press, 1996.

[PJM97]

S. Peyton Jones and E. Meijer. Henk: a typed intermediate language. In ACM SIGPLAN Workshop on Types in Compilation (TIC'97), Amsterdam, 1997.

[PJW93]

S.L. Peyton Jones and P. Wadler. Imperative functional programming. In Proc. 20th Symposium on Principles of Programming Languages (POPL'93), pages 71-84, 1993.

[PL93]

J. Passia and K.-P. Loehr. Fips: A functional-imperative language for explorative programming. ACM SIGPLAN Notices, 28(4):39-48, 1993.

[Pla84]

D. Plaisted. The occur-check problem in prolog. In Proc. IEEE Internat. Symposium on Logic Programming, pages 272-280, Atlantic City, 1984.

[Pla90]

D.A. Plaisted. Mechanical theorem proving. In R.B. Banerji, editor, Formal Techniques in Artificial Intelligence, pages 269-320. Elsevier Science Publishers, 1990.

[Pla94]

D.A. Plaisted. Equational reasoning and term rewriting systems. In Handbook of Logic in Artificial Intelligence and Logic Programming, Vol. 1. Oxford University Press, 1994.

[Plo72]

G.D. Plotkin. Building-in equational theories. In B. Meltzer and D. Michie, editors, Machine Intelligence 7, pages 73-90, 1972.

[Plo81]

G.D. Plotkin. A structural approach to operational semantics. Technical report daimi fn-19, Aarhus University, 1981.

[Plu88]

D. Plummer. Coda: An extended debugger for prolog. In Proc. 5th Conference on Logic Programming & 5th Symposium on Logic Programming (Seattle), pages 496-511. MIT Press, 1988.

[Pl{ü89]

L. Plümer. Termination Proofs for Logic Programs. PhD thesis, Univ. Dortmund, 1989.

[Pl{ü92]

L. Plümer. Automatic verification of ghc programs: Termination. In Proc. FGCS'92, 1992.

[Plu93]

D. Plump. Evaluation of Functional Expressions by Hypergraph Rewriting. PhD thesis, Univ. Bremen, 1993.

[PN91]

D. Palmer and L. Naish. Nua-prolog: An extension to the wam for parallel andorra. In Proc. International Conference on Logic Programming, pages 430-442. MIT Press, 1991.

[Poi86]

A. Poigné. On specifications, theories, and models with higher types. Information and Control, 68(1-3), 1986.

[Poi93]

V. Poirriez. Mlog: a pragmatic extension of ml with logical variables, unification and suspensions. Slides presented at the Workshop on Functional Logic Languages 1993, 1993.

[Poi94]

V. Poirriez. Mlog: a strongly typed confluent functional language with logical variables. Theoretical Computer Science, 122:201-223, 1994.

[Pou95]

D. Pountain. Constraint logic programming. BYTE Magazine, 1995.

[PP90a]

M. Proietti and A. Pettorossi. Synthesis of eureka predicates for developing logic programs. In Proc. ESOP'90, 1990.

[PP90b]

H. Przymusinska and T. Przymusinski. Semantic issues in deductive databases and logic programs. In R.B. Banerji, editor, Formal Techniques in Artificial Intelligence, pages 321-367. Elsevier Science Publishers, 1990.

[PP94]

M. Proietti and A. Pettorossi. Completeness of some transformation strategies for avoiding unnecessary logical variables. In Proc. Eleventh International Conference on Logic Programming, pages 714-729. MIT Press, 1994.

[PP97]

L. Pacholski and A. Podelski. Set constraints: A pearl in research on constraints. In Principles and Practice of Constraint Programming, pages 549-562. Springer LNCS 1330, 1997.

[PR89]

C. Pyo and U.S. Reddy. Inference of polymorphic types for logic programs. In Proc. of the 1989 North American Conference on Logic Programming, pages 1115-1132. MIT Press, 1989.

[PR97]

P. Panangaden and J. Reppy. The essence of concurrent ml. In F. Nielson, editor, ML with Concurrency: Design, Analysis, Implementation, and Application, pages 5-29. Springer, 1997.

[Pra84]

T.W. Pratt. Programming Languages, Design and Implementation. Prentice-Hall, Englewood Cliffs, NJ, 1984. Chapters on APL, FORTRAN, PL/I, Snobol4.

[Pre94a]

C. Prehofer. Decidable higher-order unification problems. In Proc. CADE-12. Springer LNAI 814, 1994.

[Pre94b]

C. Prehofer. Higher-order narrowing. In Proc. Ninth Annual IEEE Symposium on Logic in Computer Science, pages 507-516, 1994.

[Pre94c]

C. Prehofer. On modularity in term rewriting and narrowing. In Proc. 1st International Conference on Constraints in Computational Logics. Springer LNCS 845, 1994.

[Pre95a]

C. Prehofer. A call-by-need strategy for higher-order functional logic programming. In Proc. of the 1995 International Logic Programming Symposium, pages 147-161. MIT Press, 1995.

[Pre95b]

C. Prehofer. Solving Higher-order Equations: From Logic to Programming. PhD thesis, TU M{ünchen, 1995. Also appeared as Technical Report I9508.

[Pre96]

C. Prehofer. Some applications of functional logic programming. In Proc. JICSLP'96 Workshop on Multi-Paradigm Logic Programming, pages 35-45. TU Berlin, Technical Report No. 96-28, 1996.

[Pro87]

Projektgruppe ProCom. Zwischen- und abschlu\ssbericht der projektgruppe procom (prolog compiler). Univ. Dortmund, 1987.

[Pro95]

T.A. Proebsting. Burs automata generation. ACM Transactions on Programming Languages and Systems, 17(3):461-486, 1995.

[Pro97]

T.A. Proebsting. Simple translation of goal-directed evaluation. In Proceedings of the 1997 ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI), pages 1-6. ACM SIGPLAN Notices 32(5), 1997.

[Prz89]

T.C. Przymusinski. On constructive negation in logic programming. In Proc. of the 1989 North American Conference on Logic Programming. MIT Press, 1989.

[PS90a]

R.A. Paterson and J. Staples. Unification and constraint solution for metaprogramming: an overview. In Proc. META'90, 1990.

[PS90b]

L. Puel and A. Suarez. Compiling pattern matching by term decomposition. Report liens-90-7, LIENS, Paris, 1990.

[PS90c]

L. Puel and A. Suarez. Compiling pattern matching by term decomposition. Research report 4, Digital Paris Research Laboratory, 1990.

[PS95]

A. Podelski and G. Smolka. Operational semantics of constraint logic programs with coroutining. In To appear in Proc. ICLP'95, 1995.

[PT95a]

B. Pierce and D.N. Turner. Concurrent objects in a process calculus. In Theory and Practice of Parallel Programming, pages 187-215. Springer LNCS 907, 1995.

[PT95b]

B.C. Pierce and D.N. Turner. Pict language definition. Technical report, University of Indiana, 1995. Available at URL http://www.cs.indiana.edu/hyplan/pierce/ftp/pict/.

[PV83]

A. Poigne and J. Voss. Programs over abstract data types - on the implementation of abstract data types -. Report 171, Univ. Dortmund, 1983.

[PV87]

A. Poigne and J. Voss. On the implementation of abstract data types by programming language constructs. Journal of Computer and System Sciences, 34:340-376, 1987.

[PvE93]

R. Plasmeijer and M. van Eekelen. Functional Programming and Parallel Graph Rewriting. Addison-Wesley, 1993.

[PW78]

M.S. Paterson and M.N. Wegman. Linear unification. Journal of Computer and System Sciences, 17:348-375, 1978.

[PW80]

F.C.N. Pereira and D.H.D. Warren. Definite clause grammars for language analysis - a survey of the formalism and a comparison with augmented transition networks. Artificial Intelligence, 13:231-278, 1980.

[Qia89a]

Z. Qian. Higher-order polymorphic equational deduction with function constraints. Draft, 1989.

[Qia89b]

Z. Qian. Semantics of higher-order polymorphic algebraic specifications. Draft, 1989.

[Qia90]

Z. Qian. Higher-order order-sorted algebras. In Proc. of the 2nd International Conference on Algebraic and Logic Programming, pages 86-100. Springer LNCS 463, 1990.

[Qia92]

Z. Qian. Unification of higher-order patterns in linear time and space. Report 5/92, Univ. Bremen, 1992.

[Qia93a]

Z. Qian. An algebraic semantics of higher-order types with subtypes. Acta Informatica, 30:569-607, 1993.

[Qia93b]

Z. Qian. Linear unification of higher-order patterns. In Proc. TAPSOFT'93, 1993.

[Qia94]

Z. Qian. Higher-order equational logic programming. In Proc. 21st ACM Symposium on Principles of Programming Languages, pages 254-267, Portland, 1994.

[QKB96]

Z. Qian and B. Krieg-Brückner. Combining object classes, inheritance, late binding, higher-order functions and ml-style polymorphism. Technical report, Univ. Bremen, 1996.

[QN94]

Z. Qian and T. Nipkow. Reduction and unification in lambda calculi with a general notion of subtype. Journal of Automated Reasoning, 12:389-406, 1994.

[Qua99]

P. Quaglia. The pi-calculus: notes on labelled semantics. EATCS Bulletin, 68:104-114, 1999.

[RA01]

M. Rodr\'\iguez-Artalejo. Functional and cosntraint logic programming. In CCL'99, pages 202-270. Springer LNCS 2002, 2001.

[Ram90]

R. Ramakrishnan. Parallelism in logic programs. In Proc. POPL'90, pages 246-260, 1990.

[Ran88]

C. Rank. Specification and prototyping of a compiler for a small applicative language. Report mip-8823, Univ. Passau, 1988.

[Raz92]

G. Razek. Combining objects and relations. ACM SIGPLAN Notices, 27(12):66-70, 1992.

[RB95]

J.A. Robinson and J. Barklund. Vesper (working paper). Upmail technical report no. 100, Uppsala University, 1995.

[RBP+91]

J. Rumbaugh, M. Blaha, W. Premerlan, F. Eddy, and W. Lorensen. Object-Oriented Modeling and Design. Prentice-Hall, 1991.

[RC90]

S. Reeves and M. Clarke. Logic for Computer Science. Addison-Wesley, 1990.

[RCS93]

J.E. Richardson, M.J. Carey, and D.T. Schuh. The design of the e programming language. ACM Transactions on Programming Languages and Systems, 15(3):494-534, 1993.

[Red84]

U.S. Reddy. Transformation of logic programs into functional programs. In Proc. IEEE Internat. Symposium on Logic Programming, pages 187-196, Atlantic City, 1984.

[Red85]

U.S. Reddy. Narrowing as the operational semantics of functional languages. In Proc. IEEE Internat. Symposium on Logic Programming, pages 138-151, Boston, 1985.

[Red86]

U.S. Reddy. On the relationship between logic and functional languages. In D. DeGroot and G. Lindstrom, editors, Logic Programming, Functions, Relations, and Equations, pages 3-36. Prentice Hall, 1986.

[Red87]

U.S. Reddy. Functional logic languages: Part i. In Proc. Workshop on Graph Reduction, pages 401-425. Springer LNCS 279, 1987.

[Red88]

U.S. Reddy. Notions of polymorphism for predicate logic programs. Presented at LP'88, Seattle, 1988.

[Red91]

U.S. Reddy. A perspective on types for logic programs. Univ. of Illinois at Urbana-Champaign, 1991.

[Red92]

U.S. Reddy. A typed foundation for directional logic programming. Univ. of Illinois at Urbana-Champaign, 1992.

[Red94]

U.S. Reddy. Higher-order aspects of logic programming (summary). In Proc. Eleventh International Conference on Logic Programming, pages 402-418. MIT Press, 1994.

[Rei78]

R. Reiter. On closed world data bases. In H. Gallaire and J. Minker, editors, Logic and Data Bases, pages 55-76. Plenum Press, 1978.

[Rei85]

W. Reisig. Systementwurf mit Netzen. Springer, 1985.

[Ren98]

M. Renschler. Configuration spreadsheet for interactive constraint problem solving. In Proc. of the ComputlogNet Industrial Conference on Advanced Software Applications, Manchester, 1998.

[Rep91]

J. Reppy. Cml: A higher-order concurrent language. In Proc. ACM Sigplan Conference on Programming Language Design and Implementation (PLDI'91), pages 293-305, 1991.

[R{ét87a]

P. Réty. Improving basic narrowing techniques. In Proc. of the Conference on Rewriting Techniques and Applications, pages 228-241. Springer LNCS 256, 1987.

[R{ét87b]

P. Réty. Improving basic narrowing techniques and commutation properties. Report rr 681, INRIA, 1987.

[R{ét99]

P. Réty. Regular set of descendants for constructor-based rewrite systems. In Proc.\ of the 6th International Conference on Logic for Programming and Automated Reasoning (LPAR'99), pages 148-160. Springer LNCS 1705, 1999.

[Rey74]

J.C. Reynolds. Towards a theory of type structure. In Proc. Colloque sur la Programmation, pages 408-425. Springer LNCS 19, 1974.

[Rey84]

J.C. Reynolds. Polymorphism is not set-theoretic. In Proc. of the Int. Symp. on the Semantics of Data Types, Sophia-Antipolis, pages 145-156. Springer LNCS 173, 1984.

[RF85]

L. Rostek and D. Fischer. Konzepte für ein thesaurusbasiertes information retrieval am arbeitsplatz. In Sprachverarbeitung in Information und Dokumentation. Springer Informatik Fachberichte, 1985.

[RFT89]

A. Rizk, J.-M. Fellous, and M. Tueni. An object-oriented model in the concurrent logic programming language parlog. Rr 1067, INRIA, 1989.

[RG92]

K.S. Rubin and A. Goldberg. Object behavior analysis. Communications of the ACM, 35(9):48-62, 1992.

[Ric75]

M.M. Richter. Resolution, paramodulation and gentzen-systems. Report 23, RWTH Aachen, 1975.

[Ric90]

L. Ricci. Compilation of Logic Programs for Massively Parallel Systems. PhD thesis, Univ. Pisa, 1990.

[RIR93]

N. Rodriguez, R. Ierusalimschy, and J.L. Rangel. Types in school. ACM SIGPLAN Notices, 28(8):81-89, 1993.

[RKKL85]

P. Réty, C. Kirchner, H. Kirchner, and P. Lescanne. Narrower: a new algorithm for unification and its application to logic programming. In First Conference on Rewriting Techniques and Applications, pages 141-157, Dijon, 1985. Springer LNCS 202.

[Rob65]

J.A. Robinson. A machine-oriented logic based on the resolution principle. Journal of the ACM, 12(1):23-41, 1965.

[Rob69]

J.A. Robinson. Mechanizing higher-order logic. In B. Meltzer and D. Michie, editors, Machine Intelligence 4, pages 151-170, 1969.

[Rob86]

J.A. Robinson. The future of logic programming. In Proc. IFIP '86, pages 219-224. North-Holland, 1986.

[Rob88]

J.A. Robinson. Beyond loglisp: combining functional and relational programming in a reduction setting. In J.E. Hayes, D. Michie, and J. Richards, editors, Machine Intelligence 11, pages 57-68. Clarendon Press, Oxford, 1988.

[Rob92a]

J.A. Robinson. Logic and logic programming. Communications of the ACM, 35(3):40-65, 1992.

[Rob92b]

P.J. Robinson. Hierarchical Object-Oriented Design. Prentice Hall, 1992.

[Ros92]

J.P. Rosen. What orientation should ada objects take?. Communications of the ACM, 35(11):71-76, 1992.

[Rot93]

A. Roth. The practical application of prolog. AI Expert, 1993.

[Rou75]

P. Roussel. Prolog, manuel de reference et d'utilisation. Groupe Intelligence Artificielle, Université Aix-Marseille II, 1975.

[RP96]

P. Roy and F. Pachet. Conception de probémes par objets et contraintes. In Journ{ées du GDR Programmation (Orl{éans), 1996.

[RRS+96]

C.R. Ramakrishnan, I.V. Ramakrishnan, K. Sagonas, T. Swift, and D.S. Warren. Tabled logic programs: Principles, practice and applications. Slides of a tutorial at JICSLP'96, 1996.

[RS82a]

K.-J. Räihä and M. Saarinen. Testing attribute grammars for circularity. Acta Informatica, 17:185-192, 1982.

[RS82b]

J.A. Robinson and E.E. Sibert. Loglisp: Motivation, design and implementation. In K.L. Clark and S.-A. T{ärnlund, editors, Logic Programming, pages 299-313. Academic Press, 1982.

[RS94]

A. Roth and C. Spenser. Prolog in the real world - logic programming at work. PC AI Magazine, pages 42-44, 1994.

[RT81]

M.M. Richter and E. Triesch. Universelle algebra. Report 74, RWTH Aachen, 1981.

[RT84]

T. Reps and R. Teitelbaum. The synthesizer generator. In ACM, 1984.

[Rus87]

M. Rusinowitch. Theorem-proving with resolution and superposition: An extension of knuth and bendix procedure as a complete set of inference rules. Report 87-r-128, CRIN, Nancy, 1987.

[Rus89]

D.M. Russinoff. A verified prolog compiler for the warren abstract machine. Technical report act-st-292-89, MCC, 1989.

[Rus91]

M. Rusinowitch. Theorem-proving with resolution and superposition. Journal of Symbolic Computation, 1991.

[Rus92]

D.M. Russinoff. A verified prolog compiler for the warren abstract machine. Journal of Logic Programming, 13(4):367-412, 1992.

[RV97]

D. Rémy and J. Vouillon. Objective ml: A simple object-oriented extension of ml. In Proc.\ of the 24th ACM Symposium on Principles of Programming Languages (Paris), pages 40-53, 1997.

[RW69]

G. Robinson and L. Wos. Paramodulation and theorem-proving in first-order theories with equality. In B. Meltzer and D. Michie, editors, Machine Intelligence 4, pages 135-150, 1969.

[RW89]

E. Ruf and D. Weise. Nondeterminism and unification in logscheme: Integrating logic and functional programming. In Fourth International Conference on Functional Programming and Computer Architecture, pages 327-339, 1989.

[SA89a]

K. Sakai and A. Aiba. Cal: A theoretical background of constraint logic programming and its applications. Journal of Symbolic Computation, 8:589-603, 1989.

[SA89b]

R. Socher-Ambrosius. Another technique for proving completeness of resolution. Univ. Kaiserslautern, 1989.

[SA93]

S. Sato and A. Aiba. An application of cal to robotics. In F. Benhamou and A. Colmerauer, editors, Constraint Logic Programming, pages 161-173. MIT Press, 1993.

[Sah91]

D. Sahlin. An Automatic Partial Evaluator for Full Prolog. PhD thesis, SICS, 1991.

[SAK87]

G. Smolka and H. A\"\it-Kaci. Inheritance hierarchies: Semantics and unification. Technical report number ai-057-87, MCC, 1987.

[Sar90]

V.A. Saraswat. Concurrent constraint programming. In Proc. POPL'90, pages 232-245, 1990.

[Sar93]

V.A. Saraswat. Concurrent Constraint Programming. MIT Press, 1993.

[Sat87]

M. Sato. Quty: A concurrent language based on logic and function. In Proc. Fourth International Conference on Logic Programming (Melbourne), pages 1034-1056. MIT Press, 1987.

[SB89]

L. Sterling and R.D. Beer. Metainterpreters for expert system construction. Journal of Logic Programming (6), pages 163-178, 1989.

[SBHW95]

B.M. Smith, S.C. Brailsford, P.M. Hubbard, and H.P. Williams. The progressive party problem: Integer linear programming and constraint programming compared. In Principles and Practice of Constraint Programming, pages 36-52. Springer LNCS 976, 1995.

[Sce92]

A. Scedrov. A brief guide to linear logic. Previously published in EATCS Bulletin No. 41, 1992.

[Sch87]

A. Schwill. Forbidden subgraphs and reduction systems: A comparison. Technical report 2/87, Univ. Oldenburg, 1987.

[Sch88]

Ph. Schnoebelen. Refined complilation of pattern-matching for functional languages. In Algebraic and Logic Programming, pages 233-244, 1988.

[Sch89]

U. Schöning. Logik für Informatiker. BI-Verlag, Mannheim, 1989.

[Sch90]

A. Schwill. Shortest edge-disjoint paths in graphs. Technical report 1/90 (dissertation), Univ. Oldenburg, 1990.

[Sch91]

C. Scharnhorst. Entwurf eines übersetzenden narrowing-systems basierend auf der abstrakten warren-maschine (wam). Diplomarbeit, Univ. Karlsruhe, 1991.

[Sch92a]

A. Schwab. Integration ordnungsorientierter typkonzepte in logisch-funktionaler programmiersprache. Diplomarbeit, Univ. Dortmund, 1992.

[Sch92b]

J. Schwider. Ein modulkonzept mit semantischen schnittstellen für eine logisch-funktionale programmiersprache. Diplomarbeit, Univ. Dortmund, 1992.

[Sch93]

A. Schwill. Programmierstile. LOG IN, 13(4):10-21, 1993.

[Sch94a]

S. Schaub. Modula-3 Reference and Tutorial. University of North Texas, 1994.

[Sch94b]

A. Schwill. Fundamental ideas of computer science. EATCS Bulletin, (53):274-295, 1994.

[Sch97]

C. Schulte. Programming constraint inference engines. In Proceedings of the Third International Conference on Principles and Practice of Constraint Programming, pages 519-533. Springer LNCS 1330, 1997.

[SCJR80]

E. Shapiro, G. Collins, L. Johnson, and J. Ruttenberg. Pases: a programming environment for pascal, 1980.

[Sco82]

D.S. Scott. Domains for denotational semantics. In Proc. ICALP'82, pages 577-613. Springer LNCS 140, 1982.

[Ses91]

P. Sestoft. Analysis and Efficient Implementation of Functional Programs. PhD thesis, Univ. of Copenhagen, 1991.

[SG88]

W. Snyder and J.H. Gallier. Higher-Order Unification Revisited: Complete Sets of Transformations. Univ. of Pennsylvania, Philadelphia, 1988.

[SGH92]

E. Schonberg, M. Gerhardt, and C. Hayden. A technical tour of ada. Communications of the ACM, 35(11):43-52, 1992.

[SH90]

K. Shen and M. Hermenegildo. A simulation study of or- and independent and-parallelism, 1990.

[SH96]

Z. Somogyi and F. Henderson. The design and implementation of mercury. Slides of a tutorial at JICSLP'96, 1996.

[Sha83]

E. Shapiro. Algorithmic Program Debugging. MIT Press, Cambridge, Massachusetts, 1983.

[Sha86]

E. Shapiro. Concurrent prolog: A progress report. Report cs86-10, Weizmann Institute of Science, Rehovot, 1986.

[Sha89a]

E. Shapiro. The family of concurrent logic programming languages. Report cs89-08, Weizmann Institute of Science, Rehovot, 1989.

[Sha89b]

E. Shapiro. The family of concurrent logic programming languages. ACM Computing Surveys, 21(3):412-510, 1989.

[SHC96]

Z. Somogyi, F. Henderson, and T. Conway. The execution algorithm of mercury, an efficient purely declarative logic programming language. Journal of Logic Programming, 29(1-3):17-64, 1996.

[She90]

Y.-H. Sheng. Hifunlog: Logic programming with higher-order relational functions. In Proc. Seventh International Conference on Logic Programming, pages 529-545. MIT Press, 1990.

[She96]

K. Shen. Overview of daswam: Exploitation of dependent and-parallelism. Journal of Logic Programming, 29(1-3):245-293, 1996.

[SHW93]

G. Smolka, M. Henz, and J. Würtz. Object-oriented concurrent constraint programming in oz. Research report rr-93-16, DFKI, 1993.

[Sie90]

J.H. Siekmann. An introduction to unification theory. In R.B. Banerji, editor, Formal Techniques in Artificial Intelligence, pages 369-425. Elsevier Science Publishers, 1990.

[Sie98]

J. Siegel. Omg overview: Corba and the oma in enterprise computing. JACM, 41(10):37-43, 1998.

[Sim95]

H. Simonis. Applications of constraint logic programming. Slides presented at ICLP'95, 1995.

[SJ89]

F.S.K. Silbermann and B. Jayaraman. Set abstraction in functional and logic programming. In Fourth International Conference on Functional Programming and Computer Architecture, pages 313-326, 1989.

[SJ91]

F.S.K. Silbermann and B. Jayaraman. A domain-theoretic approach to functional and logic programming. Technical report tutr 91-109, Tulane University, 1991. Also in Journal of Functional Programming, Vol. 2, No. 3, 1992, pp. 273-321.

[SK88]

F. Sadri and R. Kowalski. A theorem-proving approach to database integrity. In J. Minker, editor, Foundations of Deductive Databases and Logic Programming, pages 313-362. Morgan Kaufmann, 1988.

[SKL93]

U. Schreiweis, A. Keune, and H. Langendoerfer. An integrated prolog programming environment. SIGPLAN Notices, 28(2):53-60, 1993.

[SL88]

L. Sterling and A. Lakhotia. Composing prolog meta-interpreters. In Proc. 5th Conference on Logic Programming & 5th Symposium on Logic Programming (Seattle), pages 386-403, 1988.

[Sla74]

J.R. Slagle. Automated theorem-proving for theories with simplifiers, commutativity, and associativity. Journal of the ACM, 21(4):622-642, 1974.

[SLC88]

Ph. Schnoebelen, D. Lugiez, and H. Comon. A semantics for polymorphic subtypes in computer algebra. Technical report rr 711, Laboratoire d'Informatique Fondamentale et d'Intelligence Artificelle, Grenoble, France, 1988.

[slp87]

Proc. 4th IEEE Internat. Symposium on Logic Programming, San Francisco, 1987.

[SM91]

K.H. Sinclair and D.A. Moon. The philosophy of lisp. Communications of the ACM, 34(9):40-47, 1991.

[SMI94]

T. Suzuki, A. Middeldorp, and T. Ida. Level-confluence of conditional rewrite systems with extra variables in right-hand sides. Technical report ise-tr 94-116, Univ. of Tsukuba, 1994. Also in Proc. RTA'95, Springer LNCS 914.

[SMI95]

T. Suzuki, A. Middeldorp, and T. Ida. Level-confluence of conditional rewrite systems with extra variables in right-hand sides. In Rewriting Techniques and Applications (RTA'95), pages 179-193. Springer LNCS 914, 1995.

[Smi96]

D.A. Smith. Multilog and data or-parallelism. Journal of Logic Programming, 29(1-3):195-244, 1996.

[Smo86a]

G. Smolka. Fresh: A higher-order language based on unification and multiple results. In D. DeGroot and G. Lindstrom, editors, Logic Programming, Functions, Relations, and Equations, pages 469-524. Prentice Hall, 1986.

[Smo86b]

G. Smolka. Order-sorted horn logic: Semantics and deduction. Seki report sr-86-17, FB Informatik, Univ. Kaiserslautern, 1986.

[Smo88a]

G. Smolka. Logic programming with polymorphically order-sorted types. In Proc. First International Workshop on Algebraic and Logic Programming (Gaussig, G.D.R.), pages 53-70. Springer LNCS 343, 1988.

[Smo88b]

G. Smolka. Tel (version 0.9) report and user manual. Seki report sr-87-11, FB Informatik, Univ. Kaiserslautern, 1988.

[Smo89]

G. Smolka. Logic Programming over Polymorphically Order-Sorted Types. Dissertation, FB Informatik, Univ. Kaiserslautern, 1989.

[Smo91]

G. Smolka. Residuation and guarded rules for constraint logic programming. Research report 12, DEC Paris Research Laboratory, 1991.

[Smo93]

G. Smolka. Residuation and guarded rules for constraint logic programming. In F. Benhamou and A. Colmerauer, editors, Constraint Logic Programming: Selected Research, pages 405-419. MIT Press, 1993.

[Smo94a]

G. Smolka. A calculus for hihger-order concurrent constraint programming with deep guards. Research report rr-94-03, DFKI, 1994.

[Smo94b]

G. Smolka. The definition of kerneloz. Research report rr-94-23, DFKI, 1994.

[Smo94c]

G. Smolka. A foundation for higher-order concurrent constraint programming. In Proc. 1st International Conference on Constraints in Computational Logics, pages 50-72. Springer LNCS 845, 1994.

[Smo95a]

G. Smolka. Oz: Concurrent constraint programming for real. Slides presented at ICLP'95, 1995.

[Smo95b]

G. Smolka. The oz programming model. In J. van Leeuwen, editor, Computer Science Today: Recent Trends and Developments, pages 324-343. Springer LNCS 1000, 1995.

[Smo97]

G. Smolka. Draft of the finite domain constraint chapter of the oz primer. Technical report, DFKI, 1997.

[Smo98]

G. Smolka. Concurrent constraint programming based on functional programming. In Proc. of the 1998 European Joint Conferences on Theory and Practice of Software (ETAPS). Springer LNCS, 1998.

[SMR97]

D. Seipel, J. Minker, and C. Ruiz. Model generation and state generation for disjunctive logic programs. Journal of Logic Programming, 32(1):49-69, 1997.

[Sne89]

G. Snelting. The calculus of context relations. Technical report pi-r4/89, TH Darmstadt, 1989.

[SNGM87]

G. Smolka, W. Nutt, J.A. Goguen, and J. Meseguer. Order-sorted equational computation. Seki report sr-87-14, FB Informatik, Univ. Kaiserslautern, 1987.

[SNGM89]

G. Smolka, W. Nutt, J.A. Goguen, and J. Meseguer. Order-sorted equational computation. In Hassan A{\"\i}t-Kaci and Maurice Nivat, editors, Resolution of Equations in Algebraic Structures, Volume 2, Rewriting Techniques, chapter 10, pages 297-367. Academic Press, New York, 1989.

[SNMC88]

D.W. Shin, J.H. Nang, S.R. Maeng, and J.W. Cho. The semantics of a functional logic language with input mode. In Proc. FGCS'88, pages 327-336, 1988.

[SNMC92]

D.W. Shin, J.H. Nang, S.R. Maeng, and J.W. Cho. A typed functional extension of logic programming. New Generation Computing, 10:197-221, 1992.

[Sny86]

A. Snyder. Encapsulation and inheritance in object-oriented programming languages. In Proc. OOPSLA'86, pages 38-45. SIGPLAN Notices, Vol. 21, No. 11, 1986.

[Sok89]

S. Sokolowski. Applicative high-order programming or standard ml in the battlefield. Report mip-8908, Univ. Passau, 1989.

[Som87]

Z. Somogyi. A system of precise modes for logic programs. In Proc. Fourth International Conference on Logic Programming (Melbourne), pages 769-787. MIT Press, 1987.

[S{ø}n86]

H. Søndergaard. An application of abstract interpretation of logic programs: occur check reduction. In Proc. European Symposium on Programming, pages 327-338. Springer LNCS 213, 1986.

[S{ø}n89]

H. Søndergaard. Semantics-based analysis and transformation of logic programs. Report 89/22, DIKU, Univ. of Copenhagen, 1989.

[SR90]

R.C. Sekar and I.V. Ramakrishnan. Programming in equational logic: Beyond strong sequentiality. In Proc. Logic in Computer Science (LICS'90), pages 230-241, 1990.

[SR93]

R.C. Sekar and I.V. Ramakrishnan. Programming in equational logic: Beyond strong sequentiality. Information and Computation, 104(1):78-109, 1993.

[SR95]

R. Sekar and I.V. Ramakrishnan. Fast strictness analysis based on demand propagation. ACM Transactions on Programming Languages and Systems, 17(6):896-937, 1995.

[SRP91]

V.A. Saraswat, M. Rinard, and P. Panangaden. Semantic foundations of concurrent constraint programming. In Proc. 18th ACM Symposium on Principles of Programming Languages, pages 333-352, 1991.

[SS82]

J. Siekmann and P. Szabó. Universal unification and a classification of equational theories. In Proc. 6th Conference on Automated Deduction, pages 369-389. Springer LNCS 138, 1982.

[SS85]

M. Schmidt-Schauss. A many sorted calculus with polymorphic functions based on resolution and paramodulation. In Proc. 9th IJCAI. W. Kaufmann, 1985.

[SS86a]

M. Sato and T. Sakurai. Qute: A functional language based on unification. In D. DeGroot and G. Lindstorm, editors, Logic Programming, Functions, Relations, and Equations, pages 131-155. Prentice Hall, 1986.

[SS86b]

L. Sterling and E. Shapiro. The Art of Prolog. MIT Press, 1986.

[SS91]

W. Stein and M. Sintek. Relfun/x: An experimental prolog implementation of relfun. Document d-91-01, DFKI, 1991.

[SS93]

D. Sahlin and T. Sjöland. Towards an analysis tool for akl. SICS, 1993.

[SS94a]

C. Schulte and G. Smolka. Encapsulated search for higher-order concurrent constraint programming. In Proc. of the 1994 International Logic Programming Symposium, pages 505-520. MIT Press, 1994.

[SS94b]

L. Sterling and E. Shapiro. The Art of Prolog. MIT Press, Cambridge, Massachusetts, 2nd edition, 1994.

[SS00]

A. Sandholm and M.I. Schwartzbach. A type system for dynamic web documents. In Proc.\ of the 27th ACM Symposium on Principles of Programming Languages, pages 290-301, 2000.

[SSH99]

S. Seres, M. Spivey, and T. Hoare. Algebra of logic programming. In Proc. ICLP'99. MIT Press, 1999.

[SSW94]

C. Schulte, G. Smolka, and J. Würtz. Encapsulated search and constraint programming in oz. In Proc. Second Workshop on Principles and Practice of Constraint Programming, pages 134-150. Springer LNCS 874, 1994.

[ST83a]

D. Sannela and A. Tarlecki. Building specifications in an arbitrary institution. Darft, 1983.

[ST83b]

E. Shapiro and A. Takeuchi. Object-oriented programming in concurrent prolog. Report cs83-08, Weizmann Institute of Science, Rehovot, 1983.

[ST85a]

D. Sannella and A. Tarlecki. Extended ml: an institution-independent framework for formal program development. In Workshop on Category Theory and Computer Programming, pages 364-389. Springer LNCS 240, 1985.

[ST85b]

D. Sannella and A. Tarlecki. Program specification and development in standard ml. In Proc. 12th POPL, pages 67-77, 1985.

[ST87]

E. Shapiro and A. Takeuchi. Object oriented programming in concurrent prolog. In E. Shapiro, editor, Concurrent Prolog: Collected Papers, volume 2, pages 251-273. MIT Press, 1987.

[ST92]

G. Smolka and R. Treinen. Records for logic programming. Research report rr-92-23, DFKI Saarbr{ücken, 1992.

[Sta88a]

R. Stansifer. Type inference with subtypes. In Proc. 15th POPL, pages 88-97, 1988.

[Sta88b]

R. Stansifer. Type inference with subtypes. In Proc. POPL'88, pages 88-97, 1988.

[Ste84]

J. Stelovsky. XS-2: The User Interface of an Interactive System. PhD thesis, ETH Z{ürich, 1984.

[Ste90]

J.G. Stell. Unique-sort order-sorted theories: A description as monad morphisms. In Proc. CTRS'90, 1990.

[Ste92]

G.A. Stephen. String search. Technical report tr-92-gas-01, University College of North Wales, 1992.

[Ste93]

W. Stein. Objektorientierte analysemethoden - ein vergleich. Informatik-Spektrum, 16(6):317-332, 1993.

[Sti81]

M.E. Stickel. A unification algorithm for associative-commutative functions. Journal of the ACM, 28(3):423-434, 1981.

[Str84a]

B. Stroustrup. The c++ programming language - reference manual. Computing science technical report no. 108, AT&T, 1984.

[Str84b]

B. Stroustrup. A c++ tutorial. Computing science technical report no. 113, AT&T, 1984.

[Str84c]

B. Stroustrup. Data abstraction in c. Computing science technical report no. 109, AT&T, 1984.

[Str84d]

B. Stroustrup. A set of c++ classes for co-routine style programming. Computing science technical report no. 90, AT&T, 1984.

[Stu91]

P.J. Stuckey. Constructive negation for constraint logic programming. In Proc. LICS'91, pages 328-339, 1991.

[Sub93]

V.S. Subrahmanian. Semantics of logic programming. Slides presented at ICLP'93, 1993.

[Sue91]

J. Sueggel. Parametrisierte spezifikationen: Theorie und anwendungen. Vortragsfolien, 1991.

[SW87a]

D.T. Sannella and L.A. Wallen. A calculus for the construction of modular prolog programs. In Proc. 4th IEEE Internat. Symposium on Logic Programming, pages 368-378, San Francisco, 1987.

[SW87b]

D.T. Sannella and L.A. Wallen. A calculus for the construction of modular prolog programs. Dai research report 326, Univ. of Edinburgh, 1987.

[SW90]

A. Schleiermacher and J.F.H. Winkler. The implementation of protest a prolog-debugger for a refined box model. Software - Practice & Experience, 20(10):985-1006, 1990.

[SW91]

A.P. Smith and S.A. Williams. Functional programming on transputers. submitted, 1991.

[SW92]

D.T. Sannella and L.A. Wallen. A calculus for the construction of modular prolog programs. Journal of Logic Programming, 12:147-177, 1992.

[SW93]

E. Shapiro and D.H.D. Warren. The fifth generation project: Personal perspectives. Communication of the ACM, 36(3), 1993.

[SY86]

P.A. Subrahmanyam and J.-H. You. Funlog: a computational model integrating logic programming and functional programming. In D. DeGroot and G. Lindstrom, editors, Logic Programming, Functions, Relations, and Equations, pages 157-198. Prentice Hall, 1986.

[TA90a]

A.P. Tolmach and A.W. Appel. Debugging standard ml without reverse engineering. Technical report cs-tr-253-90, Princeton University, 1990. Also in Proc. ACM Lisp and Functional Programming Conference '90, Nice.

[TA90b]

A.P. Tolmach and A.W. Appel. Debugging standard ml without reverse engineering. In Proc. ACM Lisp and Functional Programming Conference '90, pages 1-12, Nice, 1990.

[Tam84]

H. Tamaki. Semantics of a logic programming language with a reducibility predicate. In Proc. 1984 Symposium on Logic Programming, pages 259-264, 1984.

[Tar85]

A. Tarlecki. On the existence of free models in abstract algebraic institutions. Theoretical Computer Science, 37:269-304, 1985.

[Tar86]

A. Tarlecki. Quasi-varieties in abstract algebraic institutions. Journal of Computer and System Sciences, 33:333-360, 1986.

[Tay89]

A. Taylor. Removal of dereferencing and trailing in prolog compilation. In Proc. Sixth International Conference on Logic Programming (Lisboa), pages 48-60. MIT Press, 1989.

[Tay90]

A. Taylor. Lips on a mips: Results form a prolog compiler for a risc. In Proc. Seventh International Conference on Logic Programming, pages 174-185. MIT Press, 1990.

[Tay91]

A. Taylor. High performance prolog implementation through global analysis. Slides of the invited talk at PDK'91, Kaiserslautern, 1991.

[Tay96]

A. Taylor. Parma-bridging the performance gap between imperative and logic programming. Journal of Logic Programming, 29(1-3):5-16, 1996.

[TD87]

H. Touati and A. Despain. An empirical study of the warren abstract machine. In Proc. 4th IEEE Internat. Symposium on Logic Programming, pages 114-124, San Francisco, 1987.

[TDBD96]

P. Tarau, K. De Bosschere, and B. Demoen. Partial translation: towards a portable and efficient prolog implementation technology. Journal of Logic Programming, 29(1-3):65-84, 1996.

[TF86]

A. Takeuchi and K. Furukawa. Partial evaluation of prolog programs and its application to meta programming. In Proc. IFIP '86, pages 415-420. North-Holland, 1986.

[TH 88a]

TH Darmstadt. Language Definer's Guide to PSG, 1988.

[TH 88b]

TH Darmstadt. User's Guide to PSG, 1988.

[Tha85]

S.R. Thatte. On the correspondence between two classes of reduction systems. Information Processing Letters, 20:83-85, 1985.

[Tha87]

S. Thatte. A refinement of strong sequentiality for term rewriting with constructors. Information and Computation, 72:46-65, 1987.

[Thi94]

M. Thielscher. On the completeness of sldenf-resolution. Technical report aida-94-08, TH Darmstadt, 1994.

[Thi00]

P. Thiemann. Modelling html in haskell. In International Workshop on Practical Aspects of Declarative Languages (PADL'00), pages 263-277. Springer LNCS 1753, 2000.

[THM+96]

P.W. Trinder, K. Hammond, J.S. Mattson, A.S. Partridge, and S.L. Peyton Jones. Gum: A portable parallel implementation of haskell. In Proc. ACM SIGPLAN'96 Conference on Programming Language Design and Implementation, pages 79-88. ACM SIGPLAN Notices Vol. 31, No. 5, 1996.

[Tic92]

E. Tick. Parallel logic programming. Advanced Tutorial at JICSLP'92, 1992.

[Tiu92]

J. Tiuryn. Solving equational constraints in polymorphic types. In Logical Foundations of Computer Science - Tver'92, pages 480-492. Springer LNCS 620, 1992.

[TK94]

E. Tick and M. Korsloot. Determinacy testing for nondeterminate logic programming. ACM Transactions on Programming Languages and Systems, 16(1):3-34, 1994.

[TL92a]

J. Tan and I-P. Lin. Compiling dataflow analysis of logic programs. In Proc. SIGPLAN'92 PLDI, pages 106-115, 1992.

[TL92b]

D.S. Touretzky and P. Lee. Visualizing evaluation in applicative languages. Communications of the ACM, 35(10):49-59, 1992.

[TLK96]

B. Thomsen, L. Leth, and T.-M. Kuo. A facile tutorial. In Proceedings of Seventh International Conference on Concurrency Theory (CONCUR'96), pages 278-298. Springer LNCS 1119, 1996.

[TLK97]

B. Thomsen, L. Leth, and T.-M. Kuo. Facile - from toy to tool. In F. Nielson, editor, ML with Concurrency: Design, Analysis, Implementation, and Application, pages 97-144. Springer, 1997.

[TML96]

E. Tick, B.C. Massey, and J.S. Larson. Experience with the super monaco optimizing compiler. Journal of Logic Programming, 29(1-3):141-170, 1996.

[TN87]

A. Togashi and S. Noguchi. A program transformation from equational programs into logic programs. Journal of Logic Programming, 4:85-103, 1987.

[TO94]

Y. Toyama and M. Oyamaguchi. Church-rosser property and unique normal form property of non-duplicating term rewriting systems. In Fourth Int. Workshop on Conditional Term Rewriting Systems. Springer LNCS (to appear), 1994.

[TR81]

T. Teitelbaum and T. Reps. The cornell program synthesizer: A syntax-directed programming environment. Communications of the ACM, 24(9):563-573, 1981.

[TRH81]

T. Teitelbaum, T. Reps, and S. Horwitz. The why and wherefore of the cornell program synthesizer. In Proc. ACM SIGPLAN SIGOA Symposium on Text Manipulation, Portland/Oregon, pages 8-16. SIGOA Newsletter, Vol. 2, No. 1+2, 1981.

[Tro92]

A.S. Troelstra. Tutorial on linear logic. Presented at JICSLP'92, 1992.

[TS86]

H. Tamaki and T. Sato. Old resolution with tabulation. In Proc. Third International Conference on Logic Programming (London), pages 84-98. Springer LNCS 225, 1986.

[TS93]

S. Takahashi and F.S.K. Silbermann. A solution to the nontermination problem for lazy functional logic programming. Technical report 93-105, Tulane University, 1993.

[Tsa89]

A. Tsakpinis. Werkzeuge zur Optimierung von logischen Programmen: Erkenntnisse aus einem Vergleich mit attributierten Grammatiken. PhD thesis, Univ. Erlangen, 1989.

[Tur85]

D. Turner. Miranda: A non-strict functional language with polymorphic types. In Conference on Functional Programming Languages and Computer Architecture, Nancy, France, pages 1-16. Springer LNCS 201, 1985.

[Tur86a]

V.F. Turchin. The concept of a supercompiler. ACM Transactions on Programming Languages and Systems, 8(3), 1986.

[Tur86b]

A.K. Turk. Compiler optimizations for the wam. In Proc. Third International Conference on Logic Programming (London), pages 657-662. Springer LNCS 225, 1986.

[Tur86c]

D. Turner. An overview of miranda. SIGPLAN Notices, 21(12):158-166, 1986.

[Tur90]

D. Turi. Extending s-models to logic programs with negation. Univ. Pisa, 1990.

[TW84]

E. Tick and D.H.D. Warren. Towards a pipelined prolog processor. In Proc. IEEE Internat. Symposium on Logic Programming, pages 29-40, Atlantic City, 1984.

[Uch95]

S. Uchida. Current status of fgcs technology and its future directions. Slides presented at ICLP'95, 1995.

[Ued87]

K. Ueda. Making exhaustive search programs deterministic. New Generation Computing, 5:29-44, 1987.

[Ued95]

K. Ueda. Strong moding in concurrent logic/constraint programming. Slides presented at ICLP'95, 1995.

[UH95]

E. Ullán Hernández. A lazy narrowing abstract machine. Technical report dia/95/3, Universidad Complutense, Madrid, 1995.

[Van88]

M.H. VanEmden. Conditional answers for polymorphic type inference. In Proc. 5th Conference on Logic Programming & 5th Symposium on Logic Programming (Seattle), pages 590-603. MIT Press, 1988.

[Vas86]

P. Vasey. Qualified answers and their application to transformation. In Proc. Third International Conference on Logic Programming (London), pages 425-432. Springer LNCS 225, 1986.

[VD88]

R. Venken and B. Demoen. A partial evaluation system for prolog: some practical considerations. New Generation Computing, 6:279-290, 1988.

[VDKV00]

A. Van Deursen, P. Klint, and J. Visser. Domain-specific languages: An annotated bibliography. ACM SIGPLAN Notices, 35(6):26-36, 2000.

[VDSB90]

K. Verschaetse, D. De Schreye, and M. Bruynooghe. Generation and compilation of efficient computation rules. In Proc. Seventh International Conference on Logic Programming, pages 700-714. MIT Press, 1990.

[vE84]

M.H. van Emden. An interpreting algorithm for prolog programs. In J.A. Campbell, editor, Implementations of Prolog, pages 93-110. Ellis Horwood, 1984.

[vEK76]

M.H. van Emden and J.A. Kowalski. The semantics of predicate logic as a programming language. Journal of the ACM, 23(4):733-742, 1976.

[Ven84]

R. Venken. A prolog meta-interpreter for partial evaluation and its application to source to source transformation and query-optimisation. In ECAI 84, pages 91-100. North-Holland, 1984.

[vEY87]

M.H. van Emden and K. Yukawa. Logic programming with equations. Journal of Logic Programming (4), pages 265-288, 1987.

[vG86]

R.J. van Glabbeek. Notes on the methodology of ccs and csp. Report cs-r8624, CWI Amsterdam, 1986.

[VG87]

A. Van Gelder. Efficient loop detection in prolog using the tortoise-and-hare technique. Journal of Logic Programming, 4:23-31, 1987.

[VH89]

P. Van Hentenryck. Constraint Satisfaction in Logic Programming. MIT Press, 1989.

[VH90]

P. Van Hentenryck. Incremental constraint satisfaction in logic programming. In Proc. Seventh International Conference on Logic Programming, pages 189-202. MIT Press, 1990.

[VH93]

P. Van Hentenryck. Constraint logic programming. Slides presented at ICLP'93, 1993.

[VHCLC93]

P. Van Hentenryck, A. Cortesi, and B. Le Charlier. Type analysis of prolog using type graphs. Technical report no. cs-93-52, Brown University, 1993. Also appeared in ACM SIGPLAN PLDI'94.

[VHCLC94]

P. Van Hentenryck, A. Cortesi, and B. Le Charlier. Type analysis of prolog using type graphs. In ACM SIGPLAN'94 Conference on Programming Language Design and Implementation, pages 337-348. ACM SIGPLAN Notices Vol. 29 No. 6, 1994.

[VHR94]

P. Van Hentenryck and V. Ramachandran. Backtracking without trailing in clp(r-lin). In ACM SIGPLAN'94 Conference on Programming Language Design and Implementation, pages 349-360. ACM SIGPLAN Notices Vol. 29 No. 6, 1994.

[Vir99]

P. Viry. Elimination of conditions. Journal of Symbolic Computation, 28:381-400, 1999.

[Vod88a]

P.J. Voda. The constraint language trilogy: Semantics and computation, 1988.

[Vod88b]

P.J. Voda. Types of trilogy. In Proc. 5th Conference on Logic Programming & 5th Symposium on Logic Programming (Seattle), pages 580-589. MIT Press, 1988.

[VR84]

P. Van Roy. A prolog compiler for the plm. Report no. ucb/csd 84/203, Univ. of California, Berkeley, 1984.

[VR89]

P. Van Roy. An intermediate language to support prolog's unification. In Proc. of the 1989 North American Conference on Logic Programming, pages 1148-1164. MIT Press, 1989.

[VR90]

P.L. Van Roy. Can Logic Programming Execute as Fast as Imperative Programming?. PhD thesis, Univ. of California Berkeley, 1990. Report No. UCB/CSD 90/600.

[VR93]

P. Van Roy. Challenges in developing useful and practical static analysis for logic programs. Slides presented at WSA'93, 1993.

[VR94]

P. Van Roy. 1983-1993: The wonder years of sequential prolog implementation. Journal of Logic Programming, 19/20:385-441, 1994.

[VRD90]

P. Van Roy and A.M. Despain. The benefits of global dataflow analysis for an optimizing prolog compiler. In Proc. of the 1990 North American Conference on Logic Programming, pages 501-515. MIT Press, 1990.

[VRD92]

P. Van Roy and A.M. Despain. High-performance logic programming with the aquarius prolog compiler. IEEE Computer, 25(1):54-68, 1992.

[VRDW87]

P. Van Roy, B. Demoen, and Y.D. Willems. Improving the execution speed of compiled prolog with modes, clause selection, and determinism. In Proc. of the TAPSOFT '87, pages 111-125. Springer LNCS 250, 1987.

[VRHB+97]

P. Van Roy, S. Haridi, P. Brand, G. Smolka, M. Mehl, and R. Scheidhauer. Mobile objects in distributed oz. ACM Transactions on Programming Languages and Systems, 19(5):804-851, 1997.

[VSvSB89]

C.A. Vissers, G. Scollo, M. van Sinderen, and E. Brinksma. On the use of specification styles in the design of distributed systems. Presented at TAPSOFT'89, 1989.

[VTS95]

T. Vullinghs, D. Tuijnman, and W. Schulte. Lightweight guis for functional programming. In Proc.\ of the 7th International Symposium on Programming Languages, Implementations, Logics and Programs (PLILP'95), pages 341-356. Springer LNCS 982, 1995.

[Wad85]

P. Wadler. How to replace failure by a list of successes. In Functional Programming and Computer Architecture, pages 113-128. Springer LNCS 201, 1985.

[Wad87]

P. Wadler. Efficient compilation of pattern-matching. In S.L. Peyton Jones, editor, The Implementation of Functional Programming Languages, pages 78-103. Prentice Hall, 1987.

[Wad90]

P. Wadler. Deforestation: Transforming programs to eliminate trees. Theoretical Computer Science, 73:231-248, 1990.

[Wad92]

P. Wadler. The essence of functional programming. In Proc. 19th Symposium on Principles of Programming Languages (POPL'92), pages 1-14, 1992.

[Wad95]

P. Wadler. How to declare an imperative. In Proc. of the 1995 International Logic Programming Symposium, pages 18-32. MIT Press, 1995.

[Wad97]

P. Wadler. How to declare an imperative. ACM Computing Surveys, 29(3):240-263, 1997.

[Wad98a]

P. Wadler. Functional programming: An angry half-dozen. SIGPLAN Notices, 1998.

[Wad98b]

P. Wadler. Why no one uses functional languages. ACM SIGPLAN Notices, 33(8):23-27, 1998.

[WADK84]

D.S. Warren, M. Ahamad, S.K. Debray, and L.V. Kale. Executing distributed prolog programs on a broadcast network. In Proc. IEEE Internat. Symposium on Logic Programming, pages 12-21, Atlantic City, 1984.

[W{æ}r88]

A. Wærn. An implementation technqiue for the abstract interpretation of prolog. In Proc. 5th Conference on Logic Programming & 5th Symposium on Logic Programming (Seattle), pages 700-710, 1988.

[Wak97]

D. Wakeling. A haskell to java virtual machine code compiler. In Proc. 9th International Workshop on Implementation of Functional Languages (IFL'97), pages 39-52. Springer LNCS 1467, 1997.

[Wak98]

D. Wakeling. Mobile haskell: Compiling lazy functional programs for the java virtual machine. In Principles of Declarative Programming (Proc. Joint International Symposium PLILP/ALP'98), pages 335-352. Springer LNCS 1490, 1998.

[Wal83]

C. Walther. A many-sorted calculus based on resolution and paramodulation. In Proc. 8th IJCAI, pages 882-891, 1983.

[Wal87]

C. Walther. Automatisches Beweisen. In Th. Christaller, H.-W. Hein, and M.M. Richter, editors, K{ünstliche Intelligenz, pages 292-339. Springer IFB 159, 1987.

[Wal88]

C. Walther. Many-sorted unification. Journal of the ACM, 35(1):1-17, 1988.

[Wal89a]

U. Waldmann. Semantics of order-sorted specifications. Report no. 297, Univ. Dortmund, 1989.

[Wal89b]

U. Waldmann. Unification in order-sorted signatures. Technical report 298, FB Informatik, Univ. Dortmund, 1989.

[Wal90]

U. Waldmann. Compatibility of order-sorted rewrite rules. In Proc. CTRS'90, pages 407-416. Springer LNCS 516, 1990.

[Wal92]

M. Wallace. Compiling integrity checking into update procedures. Technical report ecrc-92-19, ECRC, 1992.

[Wal93]

M. Wallace. Applying constraints for scheduling. ECRC, Munich, 1993.

[Wan84]

M. Wand. A types-as-sets semantics for milner-style polymorphism. In Proc. 11th POPL, pages 158-164, 1984.

[War77]

D.H.D. Warren. Implementing prolog - compiling logic programs. 1 and 2. D.a.i. research report no. 39 and 40, University of Edinburgh, 1977.

[War80]

D.H.D. Warren. Logic programming and compiler writing. Software - Practice and Experience, 10:97-125, 1980.

[War82]

D.H.D. Warren. Higher-order extensions to prolog: are they needed?. In Machine Intelligence 10, pages 441-454, 1982.

[War83]

D.H.D. Warren. An abstract prolog instruction set. Technical note 309, SRI International, Stanford, 1983.

[War84]

D.S. Warren. Efficient prolog memory management for flexible control strategies. In Proc. IEEE Internat. Symposium on Logic Programming, pages 198-202, Atlantic City, 1984.

[War92]

D.S. Warren. Memoing for logic programs. Communications of the ACM, 35(3):93-111, 1992.

[War93]

D.H.D. Warren. Logic programming languages, parallel implementations and the andorra model. Invited talk, slides presented at ICLP'93, 1993.

[Wat82]

R.C. Waters. Program editors should not abandon text oriented commands. SIGPLAN Notices, 17(7), 1982.

[Wat87]

D.A. Watt. An action semantics of standard ml. Research report csc/87/r11, Univ. of Glasgow, 1987.

[WB89]

P. Wadler and S. Blott. How to make ad-hoc polymorphism less ad hoc. In Proc. POPL'89, pages 60-76, 1989.

[WBDH88]

P. Weeweeuw, M. Bruynooghe, and M. De Hondt. On implementing logic programming languages on a dataflow architecture. In Proc. ESOP'88, pages 359-372. Springer LNCS 300, 1988.

[WBJ90]

R.J. Wirfs-Brock and R.E. Johnson. Surveying current research in object-oriented design. Communications of the ACM, 33(9):104-124, 1990.

[WBK93]

A. Werner, A. Bockmayr, and S. Krischer. How to realize lse narrowing. Internal report 6/93, Univ. Karlsruhe, 1993.

[WBW89]

R. Wirfs-Brock and B. Wilkerson. Object-oriented design: A responsibility-driven approach. In Proc. OOPSLA'89, pages 71-75. SIGPLAN Notices 24(10), 1989.

[WBWW90]

R. Wirfs-Brock, B. Wilkerson, and L. Wiener. Designing Object-Oriented Software. Prentice Hall, 1990.

[WC87]

D.S. Warren and W. Chen. Formal semantics of a theory of modules. Technical report 87/11, SUNY at Stony Brook, 1987.

[Weg74]

B. Wegbreit. The treatment of data types in el1. Comm. of the ACM, 17(5):251-264, 1974.

[Weg87]

P. Wegner. Dimensions of object-based language design. In Proc. OOPSLA'87, pages 168-182. SIGPLAN Notices Vol. 22, No. 12, 1987.

[Weg95]

P. Wegner. Tutorial notes: Models and paradigms of interaction. Technical report cs-95-21, Brown University, 1995.

[Wer88]

U. Wertz. Vervollständigung bedingter gleichungsspezifikationen modulo einer gleichungskongruenz. Diplomarbeit, Univ. Dortmund, 1988.

[Wer91a]

A. Werner. On the minimality of lse-sl left-to-right basic narrowing. Univ. Karlsruhe, 1991.

[Wer91b]

A. Werner. Termersetzung und narrowing mit geordneten sorten. Diplomarbeit, Univ. Karlsruhe, 1991.

[WHD88]

R. Warren, M. Hermenegildo, and S.K. Debray. On the practicality of global flow analysis of logic programs. In Proc. 5th Conference on Logic Programming & 5th Symposium on Logic Programming (Seattle), pages 684-699, 1988.

[Wig90]

G.A. Wiggins. The improvement of prolog programs efficiency by compiling control: A proof theoretic view. In Proc. META'90, pages 287-305, 1990.

[Wil79]

R. Wilhelm. Attributierte grammatiken. Informatik-Spektrum, 2:123-130, 1979.

[Wil87]

T. Wilmes. Funktionale produktionssysteme als einheitliche grundlage fuer unterschiedliche programmierstile in der kuenstlichen intelligenz. Bericht nr. 8703, Univ. Kiel, 1987.

[Wil90]

J.G. Williams. A general but efficient unification algorithm. The MITRE Corporation, 1990.

[Wir83]

N. Wirth. Programming in Modula-2. Springer, 1983.

[Wit89a]

L. With. Linear order-sorted unification. Report 1989-15, TU Berlin, 1989.

[Wit89b]

L. With. Multi-sort variables - a new approach for order-sorted unification. Report 1989-19, TU Berlin, 1989.

[WLS76]

W.A. Wulf, R.L. London, and M. Shaw. An introduction to the construction and verification of alphard programs. IEEE Transactions on Software Engineering, SE-2(4):253-264, 1976.

[WM92a]

R. Wilhelm and D. Maurer. Übersetzerbau. Springer-Verlag, 1992.

[WM92b]

S. Wu and U. Manber. Fast text searching allowing errors. Communications of the ACM, 35(10):83-91, 1992.

[Wol88]

D. Wolz. Ansätze zur compilation algebraischer spezifikationen und termersetzungssystemen. Report 88-05, TU Berlin, 1988.

[Wol90]

D. Wolz. Design of a compiler for lazy pattern driven narrowing. In Recent Trends in Data Type Specification, pages 362-379. Springer LNCS 534, 1990.

[Wol92]

D.A. Wolfram. A semantics for $λ$prolog. Technical report prg-tr-8-92, University of Oxford, 1992.

[Wol94]

D.A. Wolfram. A semantics for $λ$prolog. Theoretical Computer Science 136, pages 277-289, 1994.

[Wos98]

L. Wos. Programs that offer fast, flawless, logical reasoning. JACM, 41(6):87-95, 1998.

[WP84]

M.J. Wise and D.M.W. Powers. Indexing prolog clauses via superimposed code words and field encoded words. In Proc. IEEE Internat. Symposium on Logic Programming, pages 203-210, Atlantic City, 1984.

[WPP77]

D.H.D. Warren, L.M. Pereira, and F. Pereira. Prolog - the language and its implementation compared with lisp. In Proc. ACM Symp. on AI and Programming Languages, pages 109-115. SIGPLAN/SIGART Newsletter, 1977.

[WRCS67]

L. Wos, G.A. Robinson, D.F. Carson, and L. Shalla. The concept of demodulation in theorem proving. Journal of the ACM, 14(4):698-709, 1967.

[Wya94]

G. Wyant. Introducing modula-3. LINUX Journal, 1994.

[XW88a]

J. Xu and D.S. Warren. A theory of types and type inference in logic programming. Technical report 88/15, SUNY at Stony Brook, 1988.

[XW88b]

J. Xu and D.S. Warren. A type inference system for prolog. In Proc. 5th Conference on Logic Programming & 5th Symposium on Logic Programming (Seattle), pages 604-619, 1988.

[XW89]

J. Xu and D.S. Warren. Polymorphic type inference with abstract interpretations over partial models. Technical report 89/12, SUNY at Stony Brook, 1989.

[Yam87]

A. Yamamoto. A theoretical combination of sld-resolution and narrowing. In Proc. Fourth International Conference on Logic Programming (Melbourne), pages 470-487. MIT Press, 1987.

[Yam88]

A. Yamamoto. Completeness of extended unification based on basic narrowing. In Proc. Logic Programming '88, pages 1-10, Tokyo, 1988. Springer LNCS 383.

[YCK93]

G. Yaoqing and Y. Chung Kwong. A survey of implementations of concurrent, parallel and distributed smalltalk. ACM SIGPLAN Notices, 28(9):29-35, 1993.

[YDC91]

R. Yang, I. Dutra, and V.S. Costa. Design of the andorra-i system. Technical report, Univ. of Bristol, 1991.

[YFS91]

E. Yardeni, T. Frühwirth, and E. Shapiro. Polymorphically typed logic programs. In Proc. ICLP'91. MIT Press, 1991.

[YHL93]

Z. Yuhua, T. Honglei, and X. Li. And/or parallel execution of logic programs: Exploiting dependent and-parallelism. ACM SIGPLAN Notices, 28(4):19-28, 1993.

[YL89]

J.-H. You and L. Li. Supported circumscription and its relation to logic programming with negation. In Proc. of the 1989 North American Conference on Logic Programming, pages 291-309. MIT Press, 1989.

[Yok95]

K. Yokota. Quixote: Why don't you use it?. Slides presented at ICLP'95, 1995.

[You89]

J.-H. You. Enumerating outer narrowing derivations for constructor-based term rewriting systems. Journal of Symbolic Computation, 7:319-341, 1989.

[You91]

J.-H. You. Unification modulo an equality theory for equational logic programming. Journal of Computer and System Sciences, 42:54-75, 1991.

[YS87]

E. Yardeni and E. Shapiro. A type system for logic programs. Technical report cs87-05, The Weizmann Institute of Science, 1987.

[YS91]

E. Yardeni and E. Shapiro. A type system for logic programs. Journal of Logic Programming, 10:125-153, 1991.

[Zac88]

J.L. Zachary. A pragmatic approach to equational logic programming. In Proc. 5th Conference on Logic Programming & 5th Symposium on Logic Programming (Seattle), pages 295-310, 1988.

[Zad88]

L.A. Zadeh. Fuzzy logic. Report csli-88-116, CSLI, Standford, 1988.

[Zan84]

C. Zaniolo. Object-oriented programming in prolog. In Proc. IEEE Internat. Symposium on Logic Programming, pages 265-270, Atlantic City, 1984.

[Zan97]

H. Zantema. Termination of context-sensitive rewriting. In Proc. RTA'97, pages 172-186. Springer LNCS 1232, 1997.

[Zar94]

F. Zartmann. Global analysis of functional logic programs. Technical report (forthcoming), Max-Planck-Institut f{ür Informatik, 1994.

[Zar97]

F. Zartmann. Denotational abstract interpretation of functional logic programs. In Proc. of the 4th International Symposium on Static Analysis (SAS'97), pages 141-156. Springer LNCS 1302, 1997.

[Zel84]

M.V. Zelkowitz. A small contribution to editing with a syntax directed editor. In ACM, 1984.

[Zha94]

K. Zhang. A review of exploitation of and-parallelism and combined and/or-parallelism in logic programs. ACM SIGPLAN Notices, 29(2):25-32, 1994.

[Zho93]

N.-F. Zhou. Global optimizations in a prolog compiler for the toam. Journal of Logic Programming, 15(4):275-294, 1993.

[Zob87]

J. Zobel. Derivation of polymorphic types for prolog programs. In Proc. Fourth International Conference on Logic Programming (Melbourne), pages 817-838. MIT Press, 1987.

[ZR85]

H. Zhang and J.L. Remy. Contextual rewriting. In First Conference on Rewriting Techniques and Applications, pages 46-62, Dijon, 1985. Springer LNCS 202.

[ZTU90]

N.-F. Zhou, T. Tagaki, and K. Ushijima. A matching tree oriented abstract machine for prolog. In Proc. Seventh International Conference on Logic Programming, pages 159-173. MIT Press, 1990.