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)
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 functional programming language 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 supports a powerful kind of metaprogramming based on row 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."

[4]

Example program

This is a demo program showing client, server and database code with Ajax communication, from the web demos, [5] 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: [6] 

# 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">PostgreSQL</span> Free and open-source object relational database management system

PostgreSQL, also known as Postgres, is a free and open-source relational database management system (RDBMS) emphasizing extensibility and SQL compliance. PostgreSQL features transactions with atomicity, consistency, isolation, durability (ACID) properties, automatically updatable views, materialized views, triggers, foreign keys, and stored procedures. It is supported on all major operating systems, including Linux, FreeBSD, OpenBSD, macOS, and Windows, and handles a range of workloads from single machines to data warehouses or web services with many concurrent users.

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.

<span class="mw-page-title-main">Dynamic web page</span> Type of web page

A dynamic web page is a web page constructed at runtime, as opposed to a static web page, delivered as it is stored. A server-side dynamic web page is a web page whose construction is controlled by an application server processing server-side scripts. In server-side scripting, parameters determine how the assembly of every new web page proceeds, and including the setting up of more client-side processing. A client-side dynamic web page processes the web page using JavaScript running in the browser as it loads. JavaScript can interact with the page via Document Object Model (DOM), to query page state and modify it. Even though a web page can be dynamic on the client-side, it can still be hosted on a static hosting service such as GitHub Pages or Amazon S3 as long as there is not any server-side code included.

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.

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.

In computing, logging is the act of keeping a log of events that occur in a computer system, such as problems, errors or just information on current operations. These events may occur in the operating system or in other software. A message or log entry is recorded for each such event. These log messages can then be used to monitor and understand the operation of the system, to debug problems, or during an audit. Logging is particularly important in multi-user software, to have a central overview of the operation of the system.

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.

A single-page application (SPA) is a web application or website that interacts with the user by dynamically rewriting the current web page with new data from the web server, instead of the default method of a web browser loading entire new pages. The goal is faster transitions that make the website feel more like a native app.

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. ↑ Hardesty, Larry (December 23, 2014). "Taking the grunt work out of Web development". Massachusetts Institute of Technology: MIT News. Retrieved 29 December 2016.
  5. ↑ Ur language demo programs
  6. ↑ Chlipala, Adam (January 2015). "The Ur/Web Manual – Project files". GitHub . Retrieved 8 January 2015.
  7. ↑ The Ur/Web Manual - The Structure of Web Applications
  8. ↑ 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.