View in EDS

Scala-Virtualized: linguistic reuse for deep embeddings.

Saved in:
Bibliographic Details
Title: Scala-Virtualized: linguistic reuse for deep embeddings.
Authors: Rompf, Tiark1, Amin, Nada1, Moors, Adriaan1, Haller, Philipp1, Odersky, Martin1
Source: Higher-Order & Symbolic Computation. Mar2012, Vol. 25 Issue 1, p165-207. 43p.
Subjects: Scala (Computer program language), Domain-specific programming languages, Embedded computer systems, Virtual machine systems, Programming language semantics
Abstract: Scala-Virtualized extends the Scala language to better support hosting embedded DSLs. Scala is an expressive language that provides a flexible syntax, type-level computation using implicits, and other features that facilitate the development of embedded DSLs. However, many of these features work well only for shallow embeddings, i.e. DSLs which are implemented as plain libraries. Shallow embeddings automatically profit from features of the host language through linguistic reuse: any DSL expression is just as a regular Scala expression. But in many cases, directly executing DSL programs within the host language is not enough and deep embeddings are needed, which reify DSL programs into a data structure representation that can be analyzed, optimized, or further translated. For deep embeddings, linguistic reuse is no longer automatic. Scala-Virtualized defines many of the language's built-in constructs as method calls, which enables DSLs to redefine the built-in semantics using familiar language mechanisms like overloading and overriding. This in turn enables an easier progression from shallow to deep embeddings, as core language constructs such as conditionals or pattern matching can be redefined to build a reified representation of the operation itself. While this facility brings shallow, syntactic, reuse to deep embeddings, we also present examples of what we call deep linguistic reuse: combining shallow and deep components in a single DSL in such a way that certain features are fully implemented in the shallow embedding part and do not need to be reified at the deep embedding level. [ABSTRACT FROM AUTHOR]
Copyright of Higher-Order & Symbolic Computation is the property of Springer Nature and its content may not be copied or emailed to multiple sites without the copyright holder's express written permission. Additionally, content may not be used with any artificial intelligence tools or machine learning technologies. However, users may print, download, or email articles for individual use. This abstract may be abridged. No warranty is given about the accuracy of the copy. Users should refer to the original published version of the material for the full abstract. (Copyright applies to all Abstracts.)
Database: Engineering Source
FullText Text:
  Availability: 0
Header DbId: egs
DbLabel: Engineering Source
An: 101133728
AccessLevel: 6
PubType: Academic Journal
PubTypeId: academicJournal
PreciseRelevancyScore: 0
IllustrationInfo
Items – Name: Title
  Label: Title
  Group: Ti
  Data: Scala-Virtualized: linguistic reuse for deep embeddings.
– Name: Author
  Label: Authors
  Group: Au
  Data: <searchLink fieldCode="AR" term="%22Rompf%2C+Tiark%22">Rompf, Tiark</searchLink><relatesTo>1</relatesTo><br /><searchLink fieldCode="AR" term="%22Amin%2C+Nada%22">Amin, Nada</searchLink><relatesTo>1</relatesTo><br /><searchLink fieldCode="AR" term="%22Moors%2C+Adriaan%22">Moors, Adriaan</searchLink><relatesTo>1</relatesTo><br /><searchLink fieldCode="AR" term="%22Haller%2C+Philipp%22">Haller, Philipp</searchLink><relatesTo>1</relatesTo><br /><searchLink fieldCode="AR" term="%22Odersky%2C+Martin%22">Odersky, Martin</searchLink><relatesTo>1</relatesTo>
– Name: TitleSource
  Label: Source
  Group: Src
  Data: <searchLink fieldCode="JN" term="%22Higher-Order+%26+Symbolic+Computation%22">Higher-Order & Symbolic Computation</searchLink>. Mar2012, Vol. 25 Issue 1, p165-207. 43p.
– Name: Subject
  Label: Subjects
  Group: Su
  Data: <searchLink fieldCode="DE" term="%22Scala+%28Computer+program+language%29%22">Scala (Computer program language)</searchLink><br /><searchLink fieldCode="DE" term="%22Domain-specific+programming+languages%22">Domain-specific programming languages</searchLink><br /><searchLink fieldCode="DE" term="%22Embedded+computer+systems%22">Embedded computer systems</searchLink><br /><searchLink fieldCode="DE" term="%22Virtual+machine+systems%22">Virtual machine systems</searchLink><br /><searchLink fieldCode="DE" term="%22Programming+language+semantics%22">Programming language semantics</searchLink>
– Name: Abstract
  Label: Abstract
  Group: Ab
  Data: Scala-Virtualized extends the Scala language to better support hosting embedded DSLs. Scala is an expressive language that provides a flexible syntax, type-level computation using implicits, and other features that facilitate the development of embedded DSLs. However, many of these features work well only for shallow embeddings, i.e. DSLs which are implemented as plain libraries. Shallow embeddings automatically profit from features of the host language through linguistic reuse: any DSL expression is just as a regular Scala expression. But in many cases, directly executing DSL programs within the host language is not enough and deep embeddings are needed, which reify DSL programs into a data structure representation that can be analyzed, optimized, or further translated. For deep embeddings, linguistic reuse is no longer automatic. Scala-Virtualized defines many of the language's built-in constructs as method calls, which enables DSLs to redefine the built-in semantics using familiar language mechanisms like overloading and overriding. This in turn enables an easier progression from shallow to deep embeddings, as core language constructs such as conditionals or pattern matching can be redefined to build a reified representation of the operation itself. While this facility brings shallow, syntactic, reuse to deep embeddings, we also present examples of what we call deep linguistic reuse: combining shallow and deep components in a single DSL in such a way that certain features are fully implemented in the shallow embedding part and do not need to be reified at the deep embedding level. [ABSTRACT FROM AUTHOR]
– Name: AbstractSuppliedCopyright
  Label:
  Group: Ab
  Data: <i>Copyright of Higher-Order & Symbolic Computation is the property of Springer Nature and its content may not be copied or emailed to multiple sites without the copyright holder's express written permission. Additionally, content may not be used with any artificial intelligence tools or machine learning technologies. However, users may print, download, or email articles for individual use. This abstract may be abridged. No warranty is given about the accuracy of the copy. Users should refer to the original published version of the material for the full abstract.</i> (Copyright applies to all Abstracts.)
PLink https://search.ebscohost.com/login.aspx?direct=true&site=eds-live&db=egs&AN=101133728
RecordInfo BibRecord:
  BibEntity:
    Identifiers:
      – Type: doi
        Value: 10.1007/s10990-013-9096-9
    Languages:
      – Code: eng
        Text: English
    PhysicalDescription:
      Pagination:
        PageCount: 43
        StartPage: 165
    Subjects:
      – SubjectFull: Scala (Computer program language)
        Type: general
      – SubjectFull: Domain-specific programming languages
        Type: general
      – SubjectFull: Embedded computer systems
        Type: general
      – SubjectFull: Virtual machine systems
        Type: general
      – SubjectFull: Programming language semantics
        Type: general
    Titles:
      – TitleFull: Scala-Virtualized: linguistic reuse for deep embeddings.
        Type: main
  BibRelationships:
    HasContributorRelationships:
      – PersonEntity:
          Name:
            NameFull: Rompf, Tiark
      – PersonEntity:
          Name:
            NameFull: Amin, Nada
      – PersonEntity:
          Name:
            NameFull: Moors, Adriaan
      – PersonEntity:
          Name:
            NameFull: Haller, Philipp
      – PersonEntity:
          Name:
            NameFull: Odersky, Martin
    IsPartOfRelationships:
      – BibEntity:
          Dates:
            – D: 01
              M: 03
              Text: Mar2012
              Type: published
              Y: 2012
          Identifiers:
            – Type: issn-print
              Value: 13883690
          Numbering:
            – Type: volume
              Value: 25
            – Type: issue
              Value: 1
          Titles:
            – TitleFull: Higher-Order & Symbolic Computation
              Type: main
ResultId 1