Hostname: page-component-76fb5796d-9pm4c Total loading time: 0 Render date: 2024-04-26T00:11:10.027Z Has data issue: false hasContentIssue false
  • English
  • Français

Gradual session types

Part of: ICFP2017 JFP Research Articles

Published online by Cambridge University Press:  18 November 2019

ATSUSHI IGARASHI Open the ORCID record for ATSUSHI IGARASHI [Opens in a new window] ,
PETER THIEMANN Open the ORCID record for PETER THIEMANN [Opens in a new window] ,
YUYA TSUDA Open the ORCID record for YUYA TSUDA [Opens in a new window] ,
VASCO T. VASCONCELOS  and
PHILIP WADLER
ATSUSHI IGARASHI
Affiliation:
Kyoto University, Japan (e-mail: igarashi@kuis.kyoto-u.ac.jp)
PETER THIEMANN
Affiliation:
University of Freiburg, Germany (e-mail: thiemann@informatik.uni-freiburg.de)
YUYA TSUDA
Affiliation:
Kyoto University, Japan (e-mail: tsuda@fos.kuis.kyoto-u.ac.jp)
VASCO T. VASCONCELOS
Affiliation:
LASIGE, Department of Informatics, Faculty of Sciences, University of Lisbon, Portugal (e-mail: vv@di.fc.ul.pt)
PHILIP WADLER
Affiliation:
University of Edinburgh, Scotland (e-mail: wadler@inf.ed.ac.uk)
Rights & Permissions [Opens in a new window]

Abstract

Core share and HTML view are not available for this content. However, as you have access to this content, a full PDF is available via the ‘Save PDF’ action button.

Session types are a rich type discipline, based on linear types, that lifts the sort of safety claims that come with type systems to communications. However, web-based applications and microservices are often written in a mix of languages, with type disciplines in a spectrum between static and dynamic typing. Gradual session types address this mixed setting by providing a framework which grants seamless transition between statically typed handling of sessions and any required degree of dynamic typing. We propose Gradual GV as a gradually typed extension of the functional session type system GV. Following a standard framework of gradual typing, Gradual GV consists of an external language, which relaxes the type system of GV using dynamic types; an internal language with casts, for which operational semantics is given; and a cast-insertion translation from the former to the latter. We demonstrate type and communication safety as well as blame safety, thus extending previous results to functional languages with session-based communication. The interplay of linearity and dynamic types requires a novel approach to specifying the dynamics of the language.

Type
Regular Paper
Information
Journal of Functional Programming , Volume 29 , 2019 , e17
Creative Commons
Creative Common License - CCCreative Common License - BY
This is an Open Access article, distributed under the terms of the Creative Commons Attribution licence (http://creativecommons.org/licenses/by/4.0/), unrestricted re-use, distribution, and reproduction in any medium, provided the original work is properly cited.
Copyright
© The Author(s) 2019

References

Ahmed, A., Findler, R. B., Siek, J. G. & Wadler, P. (2011) Blame for all. In Proceedings of the 38th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL 2011, Austin, TX, USA, January 26–28, 2011, Ball, T. & Sagiv, M. (eds), ACM, pp. 201–214.CrossRefGoogle Scholar
Bader, J., Aldrich, J. & Tanter, É. (2018) Gradual program verification. In Verification, Model Checking, and Abstract Interpretation – 19th International Conference, VMCAI 2018, Los Angeles, CA, USA, January 7–9, 2018, Proceedings, Dillig, I. & Palsberg, J. (eds). Lecture Notes in Computer Science, vol. 10747. Springer, pp. 25–46.CrossRefGoogle Scholar
Bañados Schwerter, F., Garcia, R. & Tanter, É. (2014) A theory of gradual effect systems. In International Conference on Functional Programming (ICFP). ACM, pp. 283–295.CrossRefGoogle Scholar
Barendregt, H. P. (1984) The Lambda Calculus: Its Syntax and Semantics. North-Holland.Google Scholar
Bierman, G., Abadi, M. & Torgersen, M. (2014) Understanding TypeScript. In European Conference on Object-Oriented Programming (ECOOP). LNCS, vol. 8586. Springer, pp. 257–281.CrossRefGoogle Scholar
Bierman, G. M., Meijer, E. & Torgersen, M. (2010) Adding dynamic types to C#. In European Conference on Object-Oriented Programming (ECOOP). LNCS. Springer, pp. 76–100.Google Scholar
Bocchi, L., Chen, T.-C., Demangeon, R., Honda, K. & Yoshida, N. (2013) Monitoring networks through multiparty session types. In Formal Techniques for Distributed Systems, Beyer, D. & Boreale, M. (eds). Springer, pp. 50–65.CrossRefGoogle Scholar
Bocchi, L., Chen, T.-C., Demangeon, R., Honda, K. & Yoshida, N. (2017) Monitoring networks through multiparty session types. Theor. Comput. Sci. 699, 33–58.CrossRefGoogle Scholar
Brady, E. (2013) Idris, a general-purpose dependently typed programming language: Design and implementation. J. Funct. Program. 23(05), 552–593.CrossRefGoogle Scholar
Caires, L. & Pfenning, F. (2010) Session types as intuitionistic linear propositions. In International Conference on Concurrency Theory (CONCUR). LNCS. Springer, pp. 222–236.CrossRefGoogle Scholar
Caires, L., Pfenning, F. & Toninho, B. (2014) Linear logic propositions as session types. Math. Struct. Comput. Sci. 26(03), 367–423.CrossRefGoogle Scholar
Carbone, M., Honda, K. & Yoshida, N. (2007) Structured communication-centred programming for web services. In De Nicola, R. (ed), Programming Languages and Systems, 16th European Symposium on Programming, ESOP 2007, Held as Part of the Joint European Conferences on Theory and Practics of Software, ETAPS 2007, Braga, Portugal, March 24–April 1, 2007, Proceedings. Lecture Notes in Computer Science, vol. 4421. Springer, pp. 2–17.CrossRefGoogle Scholar
Carbone, M., Honda, K. & Yoshida, N. (2012) Structured communication-centered programming for web services. ACM Trans. Program. Lang. Syst. 34(2), 8.CrossRefGoogle Scholar
Castagna, G., Lanvin, V., Petrucciani, T. & Siek, J. G. (2019) Gradual typing: A new perspective. PACMPL 3(POPL), 16:1–16:32.Google Scholar
Chaudhuri, A., Vekris, P., Goldman, S., Roch, M. & Levi, G. (2017) Fast and precise type checking for JavaScript. PACMPL 1(OOPSLA), 48:1–48:30.Google Scholar
Cimini, M. & Siek, J. G. (2016) The Gradualizer: A methodology and algorithm for generating gradual type systems. In Proceedings of the 43rd Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL 2016, St. Petersburg, FL, USA, January 20–22, 2016, pp. 443–455.CrossRefGoogle Scholar
Cooper, E., Lindley, S., Wadler, P. & Yallop, J. (2007) Links: Web programming without tiers. In Formal Methods for Components and Objects, de Boer, F. S., Bonsangue, M. M., Graf, S. & de Roever, W. P. (eds). Springer, pp. 266–296.CrossRefGoogle Scholar
Demangeon, R. & Honda, K. (2011) Full abstraction in a subtyped pi-calculus with linear types. In Katoen, J.-P. & König, B. (eds), CONCUR 2011 - Concurrency Theory - 22nd International Conference, CONCUR 2011, Aachen, Germany, September 6–9, 2011. Proceedings. Lecture Notes in Computer Science, vol. 6901. Springer, pp. 280–296.CrossRefGoogle Scholar
Demangeon, R., Honda, K., Hu, R., Neykova, R. & Yoshida, N. (2015) Practical interruptible conversations: Distributed dynamic verification with multiparty session types and python. Formal Methods Syst. Des. 46(3), 197–225.CrossRefGoogle Scholar
Disney, T. & Flanagan, C. (2011) Gradual information flow typing. In STOP. Available at: https://users.soe.ucsc.edu/~cormac/papers/stop11.pdfGoogle Scholar
Ernst, E., Møller, A., Schwarz, M. & Strocco, F. (2017) Message safety in Dart. Sci. Comput. Program. 133, 51–73.CrossRefGoogle Scholar
Fähndrich, M., Aiken, M., Hawblitzel, C., Hodson, O., Hunt, G. C., Larus, J. R. & Levi, S. (2006) Language support for fast and reliable message-based communication in Singularity OS. In European Conference on Computer Systems (EuroSys). ACM, pp. 177–190.CrossRefGoogle Scholar
Fennell, L. & Thiemann, P. (2012). The blame theorem for a linear lambda calculus with type dynamic. In Trends in Functional Programming, Loidl, H-W. & Peña, R. (eds). LNCS, vol. 7829. Springer, pp. 37–52.Google Scholar
Fennell, L. & Thiemann, P. (2013) Gradual security typing with references. In 2013 IEEE 26th Computer Security Foundations Symposium, New Orleans, LA, USA, June 26–28, 2013. IEEE Computer Society, pp. 224–239.CrossRefGoogle Scholar
Fennell, L. & Thiemann, P. (2016) LJGS: Gradual security types for object-oriented languages. In Krishnamurthi, S. & Lerner, B. S. (eds), 30th European Conference on Object-Oriented Programming, ECOOP 2016, July 18–22, 2016, Rome, Italy. LIPIcs, vol. 56. Schloss Dagstuhl - Leibniz-Zentrum fuer Informatik, pp. 9:1–9:26.Google Scholar
Findler, R. B. & Felleisen, M. (2002) Contracts for higher-order functions. In International Conference on Functional Programming (ICFP). ACM, pp. 48–59.CrossRefGoogle Scholar
Flanagan, C. (2006) Hybrid type checking. In Principles of Programming Languages (POPL), Morrisett, J. G. & Peyton Jones, S. L. (eds). ACM, pp. 245–256.CrossRefGoogle Scholar
Fowler, S. (2016) An Erlang implementation of multiparty session actors. In Interaction and Concurrency Experience, pp. 36–50.CrossRefGoogle Scholar
Franco, J. & Vasconcelos, V. T. (2013) A concurrent programming language with refined session types. In SEFM. LNCS, vol. 8368. Springer, pp. 15–28.Google Scholar
Garcia, R., Clark, A. M. & Tanter, É. (2016) Abstracting gradual typing. In Principles of Programming Languages (POPL). ACM, pp. 429–442.CrossRefGoogle Scholar
Garcia, R., Tanter, É., Wolff, R. & Aldrich, J. (2014) Foundations of typestate-oriented programming. ACM Trans. Program. Lang. Syst. 36(4), 12:1–12:44.CrossRefGoogle Scholar
Gay, S. & Hole, M. (2005) Subtyping for session types in the pi calculus. Acta Informatica 42(2–3), 191–225.CrossRefGoogle Scholar
Gay, S. & Vasconcelos, V. (2010) Linear type theory for asynchronous session types. J. Funct. Program. 20(01), 19–50.CrossRefGoogle Scholar
Gay, S. J. (2016) Subtyping supports safe session substitution. In A List of Successes That Can Change the World - Essays Dedicated to Philip Wadler on the Occasion of His 60th Birthday, Lindley, S., McBride, C., Trinder, P. W. & Sannella, D. (eds). Lecture Notes in Computer Science, vol. 9600. Springer, pp. 95–108.CrossRefGoogle Scholar
Gay, S. J., Vasconcelos, V. T., Ravara, A., Gesbert, N. & Caldeira, A. Z. (2010) Modular session types for distributed object-oriented programming. In Principles of Programming Languages (POPL). ACM, pp. 299–312.CrossRefGoogle Scholar
Girard, J.-Y. (1987) Linear logic. Theoret. Comput. Sci. 50(1), 1–101.CrossRefGoogle Scholar
Gommerstadt, H., Jia, L. & Pfenning, F. (2018) Session-typed concurrent contracts. In Programming Languages and Systems - 27th European Symposium on Programming, ESOP 2018, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2018, Thessaloniki, Greece, April 14–20, 2018, Proceedings, Ahmed, A. (ed). Lecture Notes in Computer Science, vol. 10801. Springer, pp. 771–798.CrossRefGoogle Scholar
Greenberg, M., Pierce, B. C. & Weirich, S. (2010) Contracts made manifest. In Principles of Programming Languages (POPL). ACM, pp. 353–364.CrossRefGoogle Scholar
Honda, K. (1993) Types for dyadic interaction. In International Conference on Concurrency Theory (CONCUR). LNCS, vol. 715. Springer, pp. 509–523.CrossRefGoogle Scholar
Honda, K., Mukhamedov, A., Brown, G., Chen, T. & Yoshida, N. (2011) Scribbling interactions with a formal foundation. In ICDCIT. LNCS, vol. 6536. Springer, pp. 55–75.CrossRefGoogle Scholar
Honda, K., Vasconcelos, V. & Kubo, M. (1998) Language primitives and type discipline for structured communication-based programming. In European Symposium on Programming (ESOP). LNCS. Springer, pp. 122–138.CrossRefGoogle Scholar
Honda, K., Yoshida, N. & Carbone, M. (2008) Multiparty asynchronous session types. In Principles of Programming Languages (POPL). ACM, pp. 273–284.CrossRefGoogle Scholar
Honda, K., Yoshida, N. & Carbone, M. (2016) Multiparty asynchronous session types. J. ACM 63(1), 9.CrossRefGoogle Scholar
Hu, R., Kouzapas, D., Pernet, O., Yoshida, N. & Honda, K. (2010) Type-safe eventful sessions in Java. In European Conference on Object-Oriented Programming (ECOOP). LNCS, vol. 6183. Springer, pp. 329–353.CrossRefGoogle Scholar
Hu, R. & Yoshida, N. (2016) Hybrid session verification through endpoint API generation. In Fundamental Approaches to Software Engineering (FASE). LNCS, vol. 9633. Springer, pp. 401–418.CrossRefGoogle Scholar
Hu, R., Yoshida, N. & Honda, K. (2008) Session-based distributed programming in Java. In European Conference on Object-Oriented Programming (ECOOP). LNCS, vol. 5142. Springer, pp. 516–541.CrossRefGoogle Scholar
Igarashi, A., Thiemann, P., Vasconcelos, V. T. & Wadler, P. (2017a) Gradual session types. PACMPL 1(ICFP), 38:1–38:28.Google Scholar
Igarashi, Y., Sekiyama, T. & Igarashi, A. (2017b) On polymorphic gradual typing. PACMPL 1(ICFP), 40:1–40:29.Google Scholar
Jafery, K. A. & Dunfield, J. (2017) Sums of uncertainty: Refinements go gradual. In Castagna, G. & Gordon, A. D. (eds), Proceedings of the 44th ACM SIGPLAN Symposium on Principles of Programming Languages, POPL 2017, Paris, France, January 18–20, 2017. ACM, pp. 804–817.CrossRefGoogle Scholar
Jespersen, T. B. L., Munksgaard, P. & Larsen, K. F. (2015) Session types for Rust. In Workshop on Generic Programming (WGP). ACM, pp. 13–22.CrossRefGoogle Scholar
Jia, L., Gommerstadt, H. & Pfenning, F. (2016) Monitors and blame assignment for higher-order session types. In Bodk, R. & Majumdar, R. (eds), Proceedings of the 43rd Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL 2016, St. Petersburg, FL, USA, January 20–22, 2016. ACM, pp. 582–594.CrossRefGoogle Scholar
Kobayashi, N., Pierce, B. C. & Turner, D. N. (1999) Linearity and the pi-calculus. ACM Trans. Program. Lang. Syst. 21(5), 914–947.CrossRefGoogle Scholar
Kouzapas, D., Dardha, O., Perera, R. & Gay, S. J. (2016) Typechecking protocols with Mungo and StMungo. In Principles and Practice of Declarative Programming (PPDP). ACM, pp. 146–159.CrossRefGoogle Scholar
Lehmann, N. & Tanter, É. (2017) Gradual refinement types. In Proceedings of the 44th ACM SIGPLAN Symposium on Principles of Programming Languages, POPL 2017, Paris, France, January 18–20, 2017, Castagna, G. & Gordon, A. D. (eds). ACM, pp. 775–788.CrossRefGoogle Scholar
Lindley, S. & Morris, J. G. (2016a) Embedding session types in Haskell. In Symposium on Haskell. ACM, pp. 133–145.CrossRefGoogle Scholar
Lindley, S. & Morris, J. G. (2016b) Talking bananas: Structural recursion for session types. In International Conference on Functional Programming (ICFP). ACM, pp. 434–447.CrossRefGoogle Scholar
Lindley, S. & Morris, J. G. (2017) Lightweight functional session types. In Behavioural Types: From Theory to Tools. River Publishers.Google Scholar
Melgratti, H. C. & Padovani, L. (2017) Chaperone contracts for higher-order sessions. PACMPL 1(ICFP), 35:1–35:29.Google Scholar
Milner, R., Parrow, J. & Walker, D. (1992) A calculus of mobile processes, I. Inform. Comput. 100(1), 1–40.CrossRefGoogle Scholar
Mostrous, D. & Vasconcelos, V. T. (2011) Session typing for a featherweight Erlang. In Coordination Models and Languages (COORDINATION). LNCS, vol. 6721. Springer, pp. 95–109.CrossRefGoogle Scholar
Neykova, R. & Yoshida, N. (2014) Multiparty session actors. In Coordination Models and Languages (COORDINATION). LNCS, vol. 8459. Springer, pp. 131–146.CrossRefGoogle Scholar
Neykova, R. & Yoshida, N. (2017) Let it recover: Multiparty protocol-induced recovery. In International Conference on Compiler Construction (CC). ACM, pp. 98–108.CrossRefGoogle Scholar
Neykova, R., Yoshida, N. & Hu, R. (2013) SPY: Local verification of global protocols. In International Conference on Runtime Verification (RV). LNCS, vol. 8174. Springer, pp. 358–363.CrossRefGoogle Scholar
Ng, N., Yoshida, N. & Honda, K. (2012) Multiparty Session C: Safe parallel programming with message optimisation. In International Conference on Modelling Techniques and Tools for Computer Performance Evaluation (TOOLS). LNCS, vol. 7304. Springer, pp. 202–218.CrossRefGoogle Scholar
Norell, U. (2009) Dependently typed programming in Agda. In Proceedings of the 4th International Workshop on Types in Language Design and Implementation. TLDI’09. ACM, pp. 1–2.CrossRefGoogle Scholar
Orchard, D. & Yoshida, N. (2016) Effects as sessions, sessions as effects. In Principles of Programming Languages (POPL). ACM, pp. 568–581.CrossRefGoogle Scholar
Ou, X., Tan, G., Mandelbaum, Y. & Walker, D. (2004) Dynamic typing with dependent types. In IFIP International Conference on Theoretical Computer Science, vol. 155. Springer, pp. 437–450.CrossRefGoogle Scholar
Padovani, L. (2017) A simple library implementation of binary sessions. J. Funct. Program 27, e4.CrossRefGoogle Scholar
Pfenning, F. & Griffith, D. (2015) Polarized substructural session types. In International Conference on Foundations of Software Science and Computation Structures. LNCS, vol. 9034. Springer, pp. 3–22.CrossRefGoogle Scholar
Pierce, B. C. (2002) Types and Programming Languages. MIT Press.Google Scholar
Polakow, J. (2015) Embedding a full linear lambda calculus in Haskell. In Symposium on Haskell. ACM, pp. 177–188.CrossRefGoogle Scholar
Pucella, R. & Tov, J. A. (2008) Haskell session types with (almost) no class. In Symposium on Haskell. ACM, pp. 25–36.CrossRefGoogle Scholar
Sackman, M. & Eisenbach, S. (2008) Session Types in Haskell: Updating Message Passing for the 21st Century. Available at: https://spiral.imperial.ac.uk:8443/handle/10044/1/5918.Google Scholar
Scalas, A. & Yoshida, N. (2016) Lightweight session programming in Scala. In European Conference on Object-Oriented Programming (ECOOP). LIPIcs. Schloss Dagstuhl, pp. 21:1–21:28.Google Scholar
Schwerter, F. B., Garcia, R. & Tanter, É. (2016) Gradual type-and-effect systems. J. Funct. Program. 26, e19.CrossRefGoogle Scholar
Sergey, I. & Clarke, D. (2012) Gradual ownership types. In Programming Languages and Systems - 21st European Symposium on Programming, ESOP 2012, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2012, Tallinn, Estonia, March 24–April 1, 2012. Proceedings, Seidl, H. (ed). Lecture Notes in Computer Science, vol. 7211. Springer, pp. 579–599.CrossRefGoogle Scholar
Siek, J., Thiemann, P. & Wadler, P. (2015a) Blame and coercion: Together again for the first time. In Programming Language Design and Implementation (PLDI), ACM, pp. 425–435.CrossRefGoogle Scholar
Siek, J. G., & Taha, W. (2006) Gradual typing for functional languages. In Scheme and Functional Programming Workshop (Scheme), pp. 81–92. Available at: http://scheme2006.cs.uchicago.edu and the paper URL is http://scheme2006.cs.uchicago.edu/13-siek.pdfGoogle Scholar
Siek, J. G. & Taha, W. (2007) Gradual typing for objects. In ECOOP. Lecture Notes in Computer Science, vol. 4609. Springer, pp. 2–27.Google Scholar
Siek, J. G. & Tobin-Hochstadt, S. (2016) The recursive union of some gradual types. In Lindley, S., McBride, C., Trinder, P. W. & Sannella, D. (eds), A List of Successes That Can Change the World - Essays Dedicated to Philip Wadler on the Occasion of His 60th Birthday. Lecture Notes in Computer Science, vol. 9600. Springer, pp. 388–410.CrossRefGoogle Scholar
Siek, J. G., Vitousek, M. M., Cimini, M. & Boyland, J. T. (2015b) Refined criteria for gradual typing. In Summit on Advances in Programming Languages (SNAPL). LIPIcs, vol. 32. Schloss Dagstuhl, pp. 274–293.Google Scholar
The Coq Development Team (2019) The coq proof assistant, version 8.9.0.Google Scholar
The Dart Team (2014) Dart programming language specification. Google, 1.2 edition.Google Scholar
Thiemann, P. (2014) Session types with gradual typing. In TGC. LNCS, vol. 8902. Springer, pp. 144–158.Google Scholar
Thiemann, P. & Fennell, L. (2014) Gradual typing for annotated type systems. In Programming Languages and Systems - 23rd European Symposium on Programming, ESOP 2014, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2014, Grenoble, France, April 5–13, 2014, Proceedings, Shao, Z. (ed). Lecture Notes in Computer Science, vol. 8410. Springer, pp. 47–66.CrossRefGoogle Scholar
Tobin-Hochstadt, S. & Felleisen, M. (2008) The design and implementation of typed Scheme. In Proceedings of the 35th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL 2008, San Francisco, California, USA, January 7–12, 2008, Necula, G. C. & Wadler, P. (eds). ACM, pp. 395–406.CrossRefGoogle Scholar
Toninho, B., Caires, L. & Pfenning, F. (2013) Higher-order processes, functions, and sessions: A monadic integration. In European Symposium on Programming (ESOP). LNCS, vol. 7792. Springer, pp. 350–369.CrossRefGoogle Scholar
Toninho, B. & Yoshida, N. (2018) Depending on session-typed processes. In FoSSaCS. Lecture Notes in Computer Science, vol. 10803. Springer, pp. 128–145.Google Scholar
Toro, M., Garcia, R. & Tanter, É. (2018) Type-driven gradual security with references. ACM Trans. Program. Lang. Syst. 40(4), 16:1–16:55.CrossRefGoogle Scholar
Toro, M., Labrada, E. & Tanter, É. (2019) Gradual parametricity, revisited. PACMPL 3(POPL), 17:1–17:30.Google Scholar
Tov, J. A. & Pucella, R. (2010) Stateful contracts for affine types. In European Symposium on Programming (ESOP). LNCS, vol. 6012. Springer, pp. 550–569.CrossRefGoogle Scholar
Vasconcelos, V. T. (2012) Fundamentals of session types. Inform. Comput. 217, 52–70.CrossRefGoogle Scholar
Vazou, N., Tanter, É. & Horn, D. V. (2018) Gradual liquid type inference. PACMPL 2(OOPSLA), 132:1–132:25.Google Scholar
Verlaguet, J. (2013) Facebook: Analysing PHP statically. In Workshop on Commercial Uses of Functional Programming (CUFP).Google Scholar
Vitousek, M. M., Swords, C. & Siek, J. G. (2017) Big types in little runtime: Open-world soundness and collaborative blame for gradual type systems. In Proceedings of the 44th ACM SIGPLAN Symposium on Principles of Programming Languages, POPL 2017, Paris, France, January 18–20, 2017, Castagna, G. & Gordon, A. D. (eds). ACM, pp. 762–774.CrossRefGoogle Scholar
Wadler, P. (2012) Propositions as sessions. In International Conference on Functional Programming (ICFP). ACM, pp. 273–286.CrossRefGoogle Scholar
Wadler, P. (2014) Propositions as sessions. J. Funct. Program. 24(2–3), 384–418.CrossRefGoogle Scholar
Wadler, P. (2015) A complement to blame. In 1st Summit on Advances in Programming Languages (SNAPL). LIPIcs, vol. 32. Schloss Dagstuhl, pp. 309–320.Google Scholar
Wadler, P. & Findler, R. B. (2009) Well-typed programs can’t be blamed. In European Symposium on Programming (ESOP). LNCS, vol. 5502. Springer, pp. 1–16.CrossRefGoogle Scholar
Walker, D. (2005) Substructural type systems. In Advanced Topics in Types and Programming Languages. MIT Press, pp. 3–43.Google Scholar
Williams, J., Morris, J. G., Wadler, P. & Zalewski, J. (2017) Mixed messages: Measuring conformance and non-interference in TypeScript. In European Conference on Object-Oriented Programming (ECOOP). LIPIcs, vol. 74. Dagstuhl, Germany: Schloss Dagstuhl, pp. 28:1–28:29.Google Scholar
Willsey, M., Prabhu, R. & Pfenning, F. (2017) Design and implementation of concurrent C0. In International Workshop on Linearity. EPTCS, vol. 238, pp. 73–82.CrossRefGoogle Scholar
Wolff, R., Garcia, R., Tanter, É. & Aldrich, J. (2011) Gradual typestate. In European Conference on Object-Oriented Programming (ECOOP). LNCS, vol. 6813. Springer, pp. 459–483.CrossRefGoogle Scholar
Yoshida, N., Hu, R., Neykova, R. & Ng, N. (2014) The Scribble protocol language. In International Symposium on Trustworthy Global Computing. LNCS, vol. 8358. Springer, pp. 22–41.Google Scholar
Yoshida, N. & Vasconcelos, V. (2007) Language primitives and type discipline for structured communication-based programming revisited: Two systems for higher-order session communication. Entcs 171(4), 73–93.Google Scholar
Submit a response

Discussions

No Discussions have been published for this article.