Ur (programming language)

Last updated
Ur, Ur/Web
Paradigms functional, reactive
Family ML, Haskell
Designed by Adam Chlipala
First appearedDecember 2014;9 years ago (2014-12) [1]
Stable release
20200209 / February 9, 2020;4 years ago (2020-02-09)
Typing discipline static, row
Platform x86-64
OS POSIX
License MIT
Filename extensions .ur, .urs, .urp
Website impredicative.com/ur
Influenced by
ML, Haskell [2]

Ur also called Ur/Web is a multi-paradigm, high-level, pure, strict, functional programming language. It is a dialect of the language ML, designed for web development, created by Adam Chlipala at the Massachusetts Institute of Technology [3] that one program can emit code for a server, web browser client, and SQL specific to a given database backend. The full implementation is free and open-source software released under an MIT License. [2]

Contents

Ur has its start and roots in a superseded progenitor language named Laconic/Web, [4] in 2006. [5]

Function

Ur supports a powerful kind of metaprogramming based on row data types . [2]

Ur/Web is Ur plus a special standard library and associated rules for parsing and optimizing. Ur/Web supports construction of dynamic web pages and applications backed by SQL databases. The signature of the standard library is such that well-typed Ur/Web programs "don't go wrong" in a very broad sense. They do not crash during particular page generations, and may not: [2]

This type safety is just the foundation of the Ur/Web methodology. It is also possible to use metaprogramming to build significant application pieces by analysis of type structure. [2]

The Ur/Web compiler also produces very efficient object code that does not use garbage collection. [2]

SQL syntax templates embedded in the language facilitate the handling of tables.

Although the syntax is based on Standard ML the language includes concepts from Haskell with added type manipulation.

Ajax call/response is serialized through a monad called transaction (corresponds to Haskell's input/output (IO)) and its marshalling and decoding is encapsulated in the rpc function.

The browser client side includes functional reactive programming facilities using the (source a) type and a signal monad .

Ur/Web not only makes web applications easier to write, it also makes them more secure.

"Let's say you want to have a calendar widget on your web page, and you're going to use a library that provides the calendar widget, and on the same page there's also an advertisement box that's based on code that's provided by the ad network," Chlipala said.

"What you don't want is for the ad network to be able to change how the calendar works or the author of the calendar code to be able to interfere with delivering the ads."

[6]

Example program

This is a demo program showing client, server and database code with Ajax communication, from the web demos, [7] with extra comments to outline each of the components:

Interface file (ML-like signature) with .urs extension:

(* the environment monad is called transaction, corresponds to Haskell's IO monad *)valmain:unit->transactionpage

Implementation file (.ur extension):

datatypelistt=Nil|Consoft*listttablet:{Id:int,A:string}PRIMARYKEYId(* server side database access, called through AJAX XmlHttpRequest                    encapsulated as ''rpc'' function (remote procedure call) *)funaddids=(* sql dml template with {[expression]} *)dml(INSERTINTOt(Id,A)VALUES({[id]},{[s]}))fundelid=dml(DELETEFROMtWHEREt.Id={[id]})funlookupid=(* haskell style monadic code *)ro<-oneOrNoRows(SELECTt.AFROMtWHEREt.Id={[id]});caseroofNone=>returnNone(* return is the ''monad'' lifting function *)|Somer=>return(Somer.T.A)(* ''check'' called by client side onClick event handler,               so it will be compiled to JavaScript as page embedded client script *)funcheckls=caselsofNil=>return()|Cons(id,ls')=>ao<-rpc(lookupid);(* Ajax call to server side *)alert(caseaoofNone=>"Nada"|Somea=>a);checkls'funmain()=idAdd<-source"";aAdd<-source"";idDel<-source"";(* generates web page with JavaScript inclusions *)return<xml><body><buttonvalue="Check values of 1, 2, and 3"onclick={fn_=>letvalmylist=1::2::3::[]incheckmylistend}/><br/><br/><buttonvalue="Add"onclick={fn_=>id<-getidAdd;a<-getaAdd;rpc(add(readErrorid)a)(* Ajax call to server side *)}/><ctextboxsource={idAdd}/><ctextboxsource={aAdd}/><br/><br/><buttonvalue="Delete"onclick={fn_=>id<-getidDel;rpc(del(readErrorid))(* Ajax call to server side *)}/><ctextboxsource={idDel}/></body></xml>

Project file (.urp extension), must contain an optional directive list followed by a listing of project modules: [8] 

# hash prefixed line comments rewrite url Module1/main        # set root URL to Module1/main function exe myexename database dbname=test            # database attrib. and parameters sql noisy.sql
$/list     # stdlib modules prefixed with "$/" module2    # if used by module1 it must precede it module1    # main module

Compile:

urweb module1   # looks for module1.urp

Execute as a web server (other modes are CGI, FastCGI, ...):

./module1.exe -p 8081   # -h : RTS options help

Libraries

Special features and problems

datatypemystruckv=Empty|Nodeof{Key:k,Value:v}funsetKey[k][v](* type polymorphism *)(_:ordk)(* implicit instance of class ord *)(callerErrNote:string)(k1:k)(my:mystruckv):mystruckv=ifk1<kminthenerror<xml>setKey:illegalk1{[callerErrNote]}</xml>elsecasemyofNoder=>Node(r--#Key++{Key=k1})|_=>error<xml>setKey:notaNode{[callerErrNote]}</xml>

corresponding signature (kind annotations (:::) implicit; (::) explicit):

conmystruc::Type->Type->Type(* two param. type constructor *)valsetKey:k:::Type->v:::Type->ordk->string->k->mystruckv->mystruckv
casemyofNode{Key=k,...}=>doWhateverk|_=>....

This error happens with types of arity > 0 in nested case or let clauses and disappears by type annotating the variables in the nested clauses.

See also

Related Research Articles

<span class="mw-page-title-main">Document Object Model</span> Convention for representing and interacting with objects in HTML, XHTML, and XML documents

The Document Object Model (DOM) is a cross-platform and language-independent interface that treats an HTML or XML document as a tree structure wherein each node is an object representing a part of the document. The DOM represents a document with a logical tree. Each branch of the tree ends in a node, and each node contains objects. DOM methods allow programmatic access to the tree; with them one can change the structure, style or content of a document. Nodes can have event handlers attached to them. Once an event is triggered, the event handlers get executed.

XML-RPC is a remote procedure call (RPC) protocol which uses XML to encode its calls and HTTP as a transport mechanism.

<span class="mw-page-title-main">Web application</span> Application that uses a web browser as a client

A web application is application software that is accessed using a web browser. Web applications are delivered on the World Wide Web to users with an active network connection.

Web development is the work involved in developing a website for the Internet or an intranet. Web development can range from developing a simple single static page of plain text to complex web applications, electronic businesses, and social network services. A more comprehensive list of tasks to which Web development commonly refers, may include Web engineering, Web design, Web content development, client liaison, client-side/server-side scripting, Web server and network security configuration, and e-commerce development.

A database trigger is procedural code that is automatically executed in response to certain events on a particular table or view in a database. The trigger is mostly used for maintaining the integrity of the information on the database. For example, when a new record is added to the employees table, new records should also be created in the tables of the taxes, vacations and salaries. Triggers can also be used to log historical data, for example to keep track of employees' previous salaries.

<span class="mw-page-title-main">JSON</span> Open standard file format and data interchange

JSON is an open standard file format and data interchange format that uses human-readable text to store and transmit data objects consisting of attribute–value pairs and arrays. It is a commonly used data format with diverse uses in electronic data interchange, including that of web applications with servers.

Ajax is a set of web development techniques that uses various web technologies on the client-side to create asynchronous web applications. With Ajax, web applications can send and retrieve data from a server asynchronously without interfering with the display and behaviour of the existing page. By decoupling the data interchange layer from the presentation layer, Ajax allows web pages and, by extension, web applications, to change content dynamically without the need to reload the entire page. In practice, modern implementations commonly utilize JSON instead of XML.

JSON-RPC is a remote procedure call (RPC) protocol encoded in JSON. It is similar to the XML-RPC protocol, defining only a few data types and commands. JSON-RPC allows for notifications and for multiple calls to be sent to the server which may be answered asynchronously.

XML Interface for Network Services (XINS) is an open-source technology for definition and implementation of internet applications, which enforces a specification-oriented approach.

<span class="mw-page-title-main">Web template system</span> System in web publishing

A web template system in web publishing allows web designers and developers work with web templates to automatically generate custom web pages, such as the results from a search. This reuses static web page elements while defining dynamic elements based on web request parameters. Web templates support static content, providing basic structure and appearance. Developers can implement templates from content management systems, web application frameworks, and HTML editors.

<span class="mw-page-title-main">Document Update Markup Language</span> XML specification

Document Update Markup Language (DUML) is an XML specification created by Brian Kardell to enable server-side logic DOM manipulation outside the context of conventional JavaScript functions.

JsonML, the JSON Markup Language is a lightweight markup language used to map between XML and JSON. It converts an XML document or fragment into a JSON data structure for ease of use within JavaScript environments such as a web browser, allowing manipulation of XML data without the overhead of an XML parser.

Microsoft SQL Server is a proprietary relational database management system developed by Microsoft. As a database server, it is a software product with the primary function of storing and retrieving data as requested by other software applications—which may run either on the same computer or on another computer across a network. Microsoft markets at least a dozen different editions of Microsoft SQL Server, aimed at different audiences and for workloads ranging from small single-machine applications to large Internet-facing applications with many concurrent users.

Web2py is an open-source web application framework written in the Python programming language. Web2py allows web developers to program dynamic web content using Python. Web2py is designed to help reduce tedious web development tasks, such as developing web forms from scratch, although a web developer may build a form from scratch if required.

Quicknet is an Ajax framework designed to develop web applications or websites that use passwords to identify correct users. Using this framework, no cleartext password would be sent over the network or stored in the server. Quicknet supports multi-language, JavaScript cooperative multitasking, AJAX call, session and password management, modular structure, XML content, and JavaScript animation. It uses PHP on the server side, and JavaScript on the client side.

In computing, Open Data Protocol (OData) is an open protocol that allows the creation and consumption of queryable and interoperable Web service APIs in a standard way. Microsoft initiated OData in 2007. Versions 1.0, 2.0, and 3.0 are released under the Microsoft Open Specification Promise. Version 4.0 was standardized at OASIS, with a release in March 2014. In April 2015 OASIS submitted OData v4 and OData JSON Format v4 to ISO/IEC JTC 1 for approval as an international standard. In December 2016, ISO/IEC published OData 4.0 Core as ISO/IEC 20802-1:2016 and the OData JSON Format as ISO/IEC 20802-2:2016.

<span class="mw-page-title-main">Opa (programming language)</span>

Opa is an open-source programming language for developing scalable web applications.

<span class="mw-page-title-main">Yesod (web framework)</span>

Yesod is a web framework based on the programming language Haskell for productive development of type-safe, representational state transfer (REST) model based, high performance web applications, developed by Michael Snoyman, et al. It is free and open-source software released under an MIT License.

Multitier programming is a programming paradigm for distributed software, which typically follows a multitier architecture, physically separating different functional aspects of the software into different tiers. Multitier programming allows functionalities that span multiple of such tiers to be developed in a single compilation unit using a single programming language. Without multitier programming, tiers are developed using different languages, e.g., JavaScript for the Web client, PHP for the Web server and SQL for the database. Multitier programming is often integrated into general-purpose languages by extending them with support for distribution.

References

  1. ↑ UrWeb is out of beta
  2. 1 2 3 4 5 6 "The Ur Programming Language Family". Impredicative.com/ur. Retrieved 3 April 2016.
  3. ↑ Chlipala, Adam (January 2015). "Ur/Web: A Simple Model for Programming the Web". MIT / Association for Computing Machinery (ACM). Retrieved 5 January 2015.
  4. ↑ Chlipala, Adam (2006). "The Laconic programming language family". SourceForge .
  5. ↑ Chlipala, Adam (2006). "Scrap Your Web Application Boilerplate, or Metaprogramming with Row Types". Adam.Chlipala.net.
  6. ↑ Hardesty, Larry (December 23, 2014). "Taking the grunt work out of Web development". Massachusetts Institute of Technology: MIT News. Retrieved 29 December 2016.
  7. ↑ Ur language demo programs
  8. ↑ Chlipala, Adam (January 2015). "The Ur/Web Manual – Project files". GitHub . Retrieved 8 January 2015.
  9. ↑ The Ur/Web Manual - The Structure of Web Applications
  10. ↑ Unexpected type error: "Substitution in constructor is blocked by a too-deep unification variable"
This page is based on this Wikipedia article
Text is available under the CC BY-SA 4.0 license; additional terms may apply.
Images, videos and audio are available under their respective licenses.