A Sound Algorithm for Asynchronous Session Subtyping and its Implementation
Session types, types for structuring communication between endpoints in distributed systems, are recently being integrated into mainstream programming languages. In practice, a very important notion for dealing with such types is that of subtyping, since it allows for typing larger classes of system...
Gespeichert in:
| Veröffentlicht in: | Logical methods in computer science Jg. 17, Issue 1 |
|---|---|
| Hauptverfasser: | , , , , |
| Format: | Journal Article |
| Sprache: | Englisch |
| Veröffentlicht: |
Logical Methods in Computer Science Association
04.03.2021
Logical Methods in Computer Science e.V |
| Schlagworte: | |
| ISSN: | 1860-5974, 1860-5974 |
| Online-Zugang: | Volltext |
| Tags: |
Tag hinzufügen
Keine Tags, Fügen Sie den ersten Tag hinzu!
|
| Abstract | Session types, types for structuring communication between endpoints in distributed systems, are recently being integrated into mainstream programming languages. In practice, a very important notion for dealing with such types is that of subtyping, since it allows for typing larger classes of system, where a program has not precisely the expected behaviour but a similar one. Unfortunately, recent work has shown that subtyping for session types in an asynchronous setting is undecidable. To cope with this negative result, the only approaches we are aware of either restrict the syntax of session types or limit communication (by considering forms of bounded asynchrony). Both approaches are too restrictive in practice, hence we proceed differently by presenting an algorithm for checking subtyping which is sound, but not complete (in some cases it terminates without returning a decisive verdict). The algorithm is based on a tree representation of the coinductive definition of asynchronous subtyping; this tree could be infinite, and the algorithm checks for the presence of finite witnesses of infinite successful subtrees. Furthermore, we provide a tool that implements our algorithm. We use this tool to test our algorithm on many examples that cannot be managed with the previous approaches, and to provide an empirical evaluation of the time and space cost of the algorithm.
Comment: This is an extended version of the CONCUR'19 version |
|---|---|
| AbstractList | Session types, types for structuring communication between endpoints in concurrent systems, are recently being integrated into mainstream programming languages. In practice, a very important notion for dealing with such types is that of subtyping, since it allows for typing larger classes of systems, where a program has not precisely the expected behavior but a similar one. Unfortunately, recent work has shown that subtyping for session types in an asynchronous setting is undecidable. To cope with this negative result, the only approaches we are aware of either restrict the syntax of session types or limit communication (by considering forms of bounded asynchrony). Both approaches are too restrictive in practice, hence we proceed differently by presenting an algorithm for checking subtyping which is sound, but not complete (in some cases it terminates without returning a decisive verdict). The algorithm is based on a tree representation of the coinductive definition of asynchronous subtyping; this tree could be infinite, and the algorithm checks for the presence of finite witnesses of infinite successful subtrees. Furthermore, we provide a tool that implements our algorithm. We use this tool to test our algorithm on many examples that cannot be managed with the previous approaches, and to provide an empirical evaluation of the time and space cost of the algorithm. Session types, types for structuring communication between endpoints in distributed systems, are recently being integrated into mainstream programming languages. In practice, a very important notion for dealing with such types is that of subtyping, since it allows for typing larger classes of system, where a program has not precisely the expected behaviour but a similar one. Unfortunately, recent work has shown that subtyping for session types in an asynchronous setting is undecidable. To cope with this negative result, the only approaches we are aware of either restrict the syntax of session types or limit communication (by considering forms of bounded asynchrony). Both approaches are too restrictive in practice, hence we proceed differently by presenting an algorithm for checking subtyping which is sound, but not complete (in some cases it terminates without returning a decisive verdict). The algorithm is based on a tree representation of the coinductive definition of asynchronous subtyping; this tree could be infinite, and the algorithm checks for the presence of finite witnesses of infinite successful subtrees. Furthermore, we provide a tool that implements our algorithm. We use this tool to test our algorithm on many examples that cannot be managed with the previous approaches, and to provide an empirical evaluation of the time and space cost of the algorithm. Session types, types for structuring communication between endpoints in distributed systems, are recently being integrated into mainstream programming languages. In practice, a very important notion for dealing with such types is that of subtyping, since it allows for typing larger classes of system, where a program has not precisely the expected behaviour but a similar one. Unfortunately, recent work has shown that subtyping for session types in an asynchronous setting is undecidable. To cope with this negative result, the only approaches we are aware of either restrict the syntax of session types or limit communication (by considering forms of bounded asynchrony). Both approaches are too restrictive in practice, hence we proceed differently by presenting an algorithm for checking subtyping which is sound, but not complete (in some cases it terminates without returning a decisive verdict). The algorithm is based on a tree representation of the coinductive definition of asynchronous subtyping; this tree could be infinite, and the algorithm checks for the presence of finite witnesses of infinite successful subtrees. Furthermore, we provide a tool that implements our algorithm. We use this tool to test our algorithm on many examples that cannot be managed with the previous approaches, and to provide an empirical evaluation of the time and space cost of the algorithm. Comment: This is an extended version of the CONCUR'19 version |
| Author | Carbone, Marco Zavattaro, Gianluigi Bravetti, Mario Yoshida, Nobuko Lange, Julien |
| Author_xml | – sequence: 1 givenname: Mario surname: Bravetti fullname: Bravetti, Mario – sequence: 2 givenname: Marco surname: Carbone fullname: Carbone, Marco – sequence: 3 givenname: Julien surname: Lange fullname: Lange, Julien – sequence: 4 givenname: Nobuko surname: Yoshida fullname: Yoshida, Nobuko – sequence: 5 givenname: Gianluigi surname: Zavattaro fullname: Zavattaro, Gianluigi |
| BackLink | https://inria.hal.science/hal-03340689$$DView record in HAL |
| BookMark | eNpVkTFPwzAQhS1UJErpH2DKSIeA7XMchy2qgFYEMQRmy3HsNlUaV3aK1H9P2iIEt9zp6b1vuHeNRp3rDEK3BN9T4CAeird5GZP0jjxSPKOYkgs0JoLjOMlSNvpzX6FpCBs8DAARlI_Rax6Vbt_VUd6unG_69Tayzkd5OHR67V3n9iEqTQiN66JyX_WHXdOtIjUEmj5Ey-2uNVvT9aofDDfo0qo2mOnPnqDP56eP-SIu3l-W87yINTDaxwCgraBZwlJNCXCtWQaWq8oCt7gmIqnAaKopY0IAMGUyizVXFINQQmcwQcszt3ZqI3e-2Sp_kE418iQ4v5LK941ujcScVAlQRTKRMi6MMjipKq1IYiGt63Rgzc6stWr_oRZ5IY_a8CmGuci-yOClZ6_2LgRv7G-AYHlqQh6bkCSVRNJBGpqAb0FIfHE |
| ContentType | Journal Article |
| Copyright | Distributed under a Creative Commons Attribution 4.0 International License |
| Copyright_xml | – notice: Distributed under a Creative Commons Attribution 4.0 International License |
| DBID | AAYXX CITATION 1XC VOOES DOA |
| DOI | 10.23638/LMCS-17(1:20)2021 |
| DatabaseName | CrossRef Hyper Article en Ligne (HAL) Hyper Article en Ligne (HAL) (Open Access) DOAJ Directory of Open Access Journals |
| DatabaseTitle | CrossRef |
| DatabaseTitleList | CrossRef |
| Database_xml | – sequence: 1 dbid: DOA name: DOAJ Directory of Open Access Journals url: https://www.doaj.org/ sourceTypes: Open Website |
| DeliveryMethod | fulltext_linktorsrc |
| Discipline | Computer Science |
| EISSN | 1860-5974 |
| ExternalDocumentID | oai_doaj_org_article_061b532a1987468eae05bbca15f37dd7 oai:HAL:hal-03340689v1 10_23638_LMCS_17_1_20_2021 |
| GroupedDBID | .4S .DC 29L 2WC 5GY 5VS AAFWJ AAYXX ADBBV ADMLS ADQAK AENEX AFPKN ALMA_UNASSIGNED_HOLDINGS ARCSS BCNDV CITATION EBS EJD FRP GROUPED_DOAJ J9A KQ8 MK~ ML~ M~E OK1 OVT P2P TR2 TUS XSB 1XC VOOES |
| ID | FETCH-LOGICAL-c342t-333cf829547c2136cc493f6abf36f0d185b3ec2c24488334ae9f0c6a2038a8c93 |
| IEDL.DBID | DOA |
| ISICitedReferencesCount | 13 |
| ISICitedReferencesURI | http://www.webofscience.com/api/gateway?GWVersion=2&SrcApp=Summon&SrcAuth=ProQuest&DestLinkType=CitingArticles&DestApp=WOS_CPL&KeyUT=000658724600020&url=https%3A%2F%2Fcvtisr.summon.serialssolutions.com%2F%23%21%2Fsearch%3Fho%3Df%26include.ft.matches%3Dt%26l%3Dnull%26q%3D |
| ISSN | 1860-5974 |
| IngestDate | Fri Oct 03 12:54:03 EDT 2025 Tue Oct 14 19:55:35 EDT 2025 Sat Nov 29 08:03:01 EST 2025 |
| IsDoiOpenAccess | true |
| IsOpenAccess | true |
| IsPeerReviewed | true |
| IsScholarly | true |
| Language | English |
| License | https://creativecommons.org/licenses/by/4.0 Distributed under a Creative Commons Attribution 4.0 International License: http://creativecommons.org/licenses/by/4.0 |
| LinkModel | DirectLink |
| MergedId | FETCHMERGED-LOGICAL-c342t-333cf829547c2136cc493f6abf36f0d185b3ec2c24488334ae9f0c6a2038a8c93 |
| ORCID | 0000-0003-3313-6409 |
| OpenAccessLink | https://doaj.org/article/061b532a1987468eae05bbca15f37dd7 |
| ParticipantIDs | doaj_primary_oai_doaj_org_article_061b532a1987468eae05bbca15f37dd7 hal_primary_oai_HAL_hal_03340689v1 crossref_primary_10_23638_LMCS_17_1_20_2021 |
| PublicationCentury | 2000 |
| PublicationDate | 2021-03-04 |
| PublicationDateYYYYMMDD | 2021-03-04 |
| PublicationDate_xml | – month: 03 year: 2021 text: 2021-03-04 day: 04 |
| PublicationDecade | 2020 |
| PublicationTitle | Logical methods in computer science |
| PublicationYear | 2021 |
| Publisher | Logical Methods in Computer Science Association Logical Methods in Computer Science e.V |
| Publisher_xml | – name: Logical Methods in Computer Science Association – name: Logical Methods in Computer Science e.V |
| SSID | ssj0000331826 |
| Score | 2.3402126 |
| Snippet | Session types, types for structuring communication between endpoints in distributed systems, are recently being integrated into mainstream programming... Session types, types for structuring communication between endpoints in concurrent systems, are recently being integrated into mainstream programming... |
| SourceID | doaj hal crossref |
| SourceType | Open Website Open Access Repository Index Database |
| SubjectTerms | Computer Science computer science - programming languages Programming Languages |
| Title | A Sound Algorithm for Asynchronous Session Subtyping and its Implementation |
| URI | https://inria.hal.science/hal-03340689 https://doaj.org/article/061b532a1987468eae05bbca15f37dd7 |
| Volume | 17, Issue 1 |
| WOSCitedRecordID | wos000658724600020&url=https%3A%2F%2Fcvtisr.summon.serialssolutions.com%2F%23%21%2Fsearch%3Fho%3Df%26include.ft.matches%3Dt%26l%3Dnull%26q%3D |
| hasFullText | 1 |
| inHoldings | 1 |
| isFullTextHit | |
| isPrint | |
| journalDatabaseRights | – providerCode: PRVAON databaseName: DOAJ Directory of Open Access Journals customDbUrl: eissn: 1860-5974 dateEnd: 99991231 omitProxy: false ssIdentifier: ssj0000331826 issn: 1860-5974 databaseCode: DOA dateStart: 20040101 isFulltext: true titleUrlDefault: https://www.doaj.org/ providerName: Directory of Open Access Journals – providerCode: PRVHPJ databaseName: ROAD: Directory of Open Access Scholarly Resources customDbUrl: eissn: 1860-5974 dateEnd: 99991231 omitProxy: false ssIdentifier: ssj0000331826 issn: 1860-5974 databaseCode: M~E dateStart: 20040101 isFulltext: true titleUrlDefault: https://road.issn.org providerName: ISSN International Centre |
| link | http://cvtisr.summon.serialssolutions.com/2.0.0/link/0/eLvHCXMwrV1NS-0wEA0iLtz4-R5evwjiwsejmGR608RdFUXwKsJVcBfSNFFBq3ir4Ob99jdJe0VXbtx0EZqmzCQ5M23OGUJ2HfOgqzrHJS5ZlkuusspDyOogmHcFeKkSUXhUXFyomxt9-anUVzwT1skDd4bbR7yphiBsTI5z7Gg9G1aVs3wYoKjrxCNnhf6UTKU9GCAGzh1LRgBOsv3R-dE448UePxDsD6b8_AsSJcF-xJe76ffUhC8nS2ShDwxp2b3QMpnxzQpZnBZdoP0aXCVnJR3HUki0fLh9wsz-7pFi3EnLyXvjotAtZvJ03IltUNwV2vdIiKIWO9y3E5rEgB97vlHzi1yfHF8dnWZ9RYTMQS7aDABcUPHXXOEEB-lcriFIWwWQgdWIvRV4JxxidiwinFuvA3PSCgbKKqfhN5ltnhq_RqhGbFc2cpojt1QXVS1rheFhqCWOYfWA_J1axzx3whcGE4ZkSxNtaXhhuBHYhLYckMNowI87o2h1akBXmt6V5jtXDsgOmv_LM07LkYlt6E-MPJR-4-s_MdIGmY9vnc6S5Ztktn159Vtkzr2195OX7TSV8Hr-7_g_jl_MYQ |
| linkProvider | Directory of Open Access Journals |
| openUrl | ctx_ver=Z39.88-2004&ctx_enc=info%3Aofi%2Fenc%3AUTF-8&rfr_id=info%3Asid%2Fsummon.serialssolutions.com&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&rft.genre=article&rft.atitle=A+Sound+Algorithm+for+Asynchronous+Session+Subtyping+and+its+Implementation&rft.jtitle=Logical+methods+in+computer+science&rft.au=Bravetti%2C+Mario&rft.au=Carbone%2C+Marco&rft.au=Lange%2C+Julien&rft.au=Yoshida%2C+Nobuko&rft.date=2021-03-04&rft.pub=Logical+Methods+in+Computer+Science+Association&rft.eissn=1860-5974&rft_id=info:doi/10.23638%2FLMCS-17%281%3A20%292021&rft.externalDBID=HAS_PDF_LINK&rft.externalDocID=oai%3AHAL%3Ahal-03340689v1 |
| thumbnail_l | http://covers-cdn.summon.serialssolutions.com/index.aspx?isbn=/lc.gif&issn=1860-5974&client=summon |
| thumbnail_m | http://covers-cdn.summon.serialssolutions.com/index.aspx?isbn=/mc.gif&issn=1860-5974&client=summon |
| thumbnail_s | http://covers-cdn.summon.serialssolutions.com/index.aspx?isbn=/sc.gif&issn=1860-5974&client=summon |