1 / 16

Formalizing Homogeneous Language Embeddings

This paper explores language factories and DSLs, with a focus on merging syntax and semantics for reusable language components. It introduces a model for DSLs using mu-calculus and provides examples of language embedding. The work also discusses practical applications, such as a DSL for SQL and HTML integration. Further research includes parsing, static analysis, logic for combining language components, and practical considerations. For more information, contact Tony Clark or Laurence Tratt from their respective universities.

jerod
Download Presentation

Formalizing Homogeneous Language Embeddings

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Formalizing Homogeneous Language Embeddings Tony Clark Centre for Model Driven Software Engineering, School of Computing, Thames Valley University tony.clark@tvu.ac.uk http://itcentre.tvu.ac.uk/~clark/ Laurence Tratt School of Design Engineering and Computing, Bournemouth University laurie@tratt.net http://tratt.net/laurie/

  2. Overview • Language Factories and DSLs • An example and some properties • A language model for DSLs • The mu-calculus for DSLs • Some examples • Further work.

  3. Language Factories The ability to construct new languages by combining precisely defined, reusable, language components and templates.

  4. Language Component program A block B do C do D end do E end A E parse B D C Abstract Syntax Tree σ σ σ σ σ Execution Trace

  5. Problem Addressed Reusable Language Component Parametric Language Component • Questions: • how can syntax be merged? • how can semantics be merged? • how can we specify the combination?

  6. An Application of DSLs let results = langsql:SQL[ select name,agefrom Customer where age > 18] inlanghtml:HTML[ <TABLE> forname,agein results do <TR> <TD> name </TD> <TD> age </TD> </TR> </TABLE> ]

  7. A host language(G) A Model for DSL Embedding E B evalG σ σ σ σ σ σ C V load unload Z W w w w w w evalH Y X embedded language(H)

  8. The mu-Calculus E ::= V variables | fun(V) E functions | E E applications | (E,E,E) language def | lang E:T[C] language embed | ...

  9. Abstract Syntax type Exp(T) =Var(String) | Lambda(String,Exp(T)) | Apply(Exp(T),Exp(T)) | (Exp(T),Exp(T),Exp(T)) | Lang(T) | ...

  10. Semantics evalExp(eval)(s) = case s of ... standard SECD except for... (R:():s,e,App:c,d) -> eval((s,e,c,d):s,e,c,d) (I:v:s,e,App:c,d) -> eval(v) end

  11. Loading and Unloading translate terminal embedded to host state lang(eval,load,unload):t[c] is equivalent to: I(newState) where newState = unload(termState,initialState) where termState = eval(startState) where startState = load(initialState,parse(t)(c)) where initialState = R() produce embedded terminal state install the host state translate host state to embedded initial state reify the host state

  12. mu-calculus Embedded in Itself Mu = Y(Exp) evalMu = Y(evalExp) loadMu((s,e,c,d),x) = (s,e,x:s,d) unloadMu(s,_) = s muL = (evalMu,loadMu,unloadMu) fun(x) langmuL:Mu[ fun(y) langmuL:Mu[x + y]]

  13. Let Binding: Semantics type LetExp(T) = Let(String,Let(T),Let(T)) | Exp(T) type Let = Y(LetExp) evalLetExp(eval)(s) = case s of (s,e,Let(n,x,b):c,d) -> eval(s,e,x:Let(n,b):c,d) (v:s,e,Let(n,b):c,d) -> eval([],e[n->v],[b],(s,e,c,d)) else evalExp(eval)(s) end

  14. Let-Binding: Language Definition type Let = Y(LetExp) evalLet = Y(evalLetExp) loadLet((s,e,c,d),x) = (s,e,x:c,d) unoadLet(s,_) = s letL = (evalLet,loadLet,unloadLet) fun(x) lang letL:Let[ let y = x + 1 in y ]

  15. Other Examples langletL:Let[let mkArray = fun(limit) langarrayL:Array [ 0 .. limit ]in mkArray(100)] langletL:Let[ let x = ... in langabortL:Abort[ stop if(x > 100) ]]

  16. Review and Further Work • mu-Calculus for semantic analysis of language embedding. • Further work: • Parsing • Static Analysis • Logic for combining language components • Practical considerations

More Related