9
views
0
recommends
+1 Recommend
0 collections
    0
    shares
      • Record: found
      • Abstract: found
      • Article: found
      Is Open Access

      Reconciling positional and nominal binding

      Preprint
      , ,

      Read this article at

      Bookmark
          There is no author summary for this article yet. Authors can add summaries to their articles on ScienceOpen to make them more accessible to a non-specialist audience.

          Abstract

          We define an extension of the simply-typed lambda calculus where two different binding mechanisms, by position and by name, nicely coexist. In the former, as in standard lambda calculus, the matching between parameter and argument is done on a positional basis, hence alpha-equivalence holds, whereas in the latter it is done on a nominal basis. The two mechanisms also respectively correspond to static binding, where the existence and type compatibility of the argument are checked at compile-time, and dynamic binding, where they are checked at run-time.

          Related collections

          Most cited references12

          • Record: found
          • Abstract: not found
          • Article: not found

          MetaML and multi-stage programming with explicit annotations

            Bookmark
            • Record: found
            • Abstract: not found
            • Article: not found

            Contextual modal type theory

              Bookmark
              • Record: found
              • Abstract: found
              • Article: not found

              Staged computation with names and necessity

              Staging is a programming technique for dividing the computation in order to exploit the early availability of some arguments. In the early stages the program uses the available arguments to generate, at run time, the code for the late stages. A type system for staging should ensure that only well-typed expressions are generated, and that only expressions with no free variables are permitted for evaluation. In this paper, we present a calculus for staged computation in which code from the late stages is composed by splicing smaller code fragments into a larger context, possibly incurring capture of free variables. The type system ensures safety by tracking the names of free variables for each code fragment. The type system is based on the necessity operator □ from constructive modal logic, which we index with a set of names C. Our type □ C A classifies expressions of type A that belong to the late stage, and whose free names are in the set C.
                Bookmark

                Author and article information

                Journal
                30 July 2013
                Article
                10.4204/EPTCS.121.6
                1307.8207
                d75fdb19-3515-4a07-99ff-5c2999dcab49

                http://arxiv.org/licenses/nonexclusive-distrib/1.0/

                History
                Custom metadata
                EPTCS 121, 2013, pp. 81-93
                In Proceedings ITRS 2012, arXiv:1307.7849
                cs.PL cs.LO cs.SE
                EPTCS

                Comments

                Comment on this article