View source for Ur (programming language)

{{Infobox programming language
| name = Ur, Ur/Web
| logo = <!-- Filename only -->
| logo caption = 
| paradigms = [[Functional programming|functional]], [[Reactive programming|reactive]]
| family = [[ML (programming language)|ML]], [[Haskell]]
| designer = Adam Chlipala
| developers = <!-- or: | developer = -->
| released = {{Start date and age|2014|12}}<ref>[https://www.reddit.com/r/programming/comments/2qbdm0/urweb_is_out_of_beta/ UrWeb is out of beta]</ref>
| latest release version = 20200209
| latest release date = {{Start date and age|2020|02|09}}
| typing = [[Static type|static]], row
| platform = [[x86-64]]
| operating system = [[POSIX]]
| license = [[MIT License|MIT]]
| website = {{URL|impredicative.com/ur}}
| file ext = .ur, .urs, .urp
| file format = <!-- or: | file formats = -->
| implementations = 
| dialects = 
| influenced by = [[ML (programming language)|ML]], [[Haskell]]<ref name="ur-pl-family">{{cite web
 |url=http://impredicative.com/ur/
 |title=The Ur Programming Language Family
 |publisher=Impredicative.com/ur
 |access-date=3 April 2016}}</ref>
| influenced =
}}
'''Ur''' also called '''Ur/Web''' is a [[Comparison of multi-paradigm programming languages|multi-paradigm]], [[High-level programming language|high-level]], [[Purely functional programming|pure]], [[Strict programming language|strict]], [[Functional programming|functional]] [[programming language]]. It is a [[Dialect (computing)|dialect]] of the language [[ML (programming language)|ML]], designed for [[web development]], created by Adam Chlipala at the [[Massachusetts Institute of Technology]]<ref>{{cite web
 |last1=Chlipala
 |first1=Adam
 |date=January 2015
 |url=https://dspace.mit.edu/handle/1721.1/92321
 |title=Ur/Web: A Simple Model for Programming the Web
 |publisher=MIT / Association for Computing Machinery (ACM)
 |access-date= 5 January 2015}}</ref> that one program can emit code for a [[Server (computing)|server]], [[web browser]] client, and [[SQL]] specific to a given [[database]] [[Frontend and backend|backend]]. The full implementation is [[free and open-source software]] released under an [[MIT License]].<ref name="ur-pl-family"/>

Ur has its start and roots in a superseded progenitor language named ''Laconic/Web'',<ref>{{Cite web |last1=Chlipala |first1=Adam |date=2006 |url=https://laconic.sourceforge.net/ |title=The Laconic programming language family |website=[[SourceForge]]}}</ref> in 2006.<ref>{{Cite web |last1=Chlipala |first1=Adam |date=2006 |url=http://adam.chlipala.net/papers/LaconicTR/ |title=Scrap Your Web Application Boilerplate, or Metaprogramming with Row Types |website=Adam.Chlipala.net}}</ref>

== Function ==
''Ur'' supports a powerful kind of [[metaprogramming]] based on ''row [[data type]]s''.<ref name="ur-pl-family"/>

''Ur/Web'' is Ur plus a special standard [[Library (computing)|library]] and associated rules for [[parsing]] and optimizing. Ur/Web supports construction of [[dynamic web page]]s 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:<ref name="ur-pl-family"/>
* Suffer from any kinds of [[code injection]] attacks
* Return invalid [[HTML]]
* Contain dead intra-application links
* Have mismatches between [[Form (HTML)|HTML forms]] and the fields expected by their handlers
* Include client-side code that makes incorrect assumptions about the "[[Ajax (programming)|Ajax]]"-style services that the remote web server provides
* Attempt invalid [[SQL]] queries
* Use improper [[Marshalling (computer science)|marshaling]] or unmarshaling in communication with [[SQL database]]s or between [[web browser]]s and [[web server]]s

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.<ref name="ur-pl-family"/>

The ''Ur/Web'' compiler also produces very efficient object code that does not use [[Garbage collection (computer science)|garbage collection]].<ref name="ur-pl-family"/>

[[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 (programming)|Ajax]] call/response is serialized through a [[Monad (functional programming)|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 programming|functional]] [[reactive programming]] facilities using the ''<code>(source a)</code>'' type and a ''signal [[Monad (functional programming)|monad]]''.

{{Quote box|align=right|width=50%|quote=
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."|source=<ref name="zdnet-rob-oneill">{{cite news
 |last1=Hardesty |first1=Larry
 |date=December 23, 2014
 |url=https://news.mit.edu/2014/new-programming-language-coordinates-web-page-components-1223
 |title=Taking the grunt work out of Web development
 |publisher=Massachusetts Institute of Technology: MIT News
 |access-date=29 December 2016}}</ref>
}}

== Example program ==
This is a demo program showing client, server and database code with [[Ajax (programming)|Ajax]] communication, from the web demos,<ref>[http://impredicative.com/ur/demo/ Ur language demo programs]</ref> with extra comments to outline each of the components:

Interface file ([[Standard ML|ML]]-like signature) with {{Not a typo|.urs}} extension:
<syntaxhighlight lang="sml">
(* the environment monad is called transaction, corresponds to Haskell's IO monad *)
val main : unit -> transaction page
</syntaxhighlight>

Implementation file (.ur extension):
<syntaxhighlight lang="sml">
datatype list t = Nil | Cons of t * list t

table t : { Id : int, A : string }
  PRIMARY KEY Id

(* server side database access, called through AJAX XmlHttpRequest
                    encapsulated as ''rpc'' function (remote procedure call) *)
fun add id s =
    (* sql dml template with {[expression]} *)
    dml (INSERT INTO t (Id, A) VALUES ({[id]}, {[s]}))

fun del id =
    dml (DELETE FROM t WHERE t.Id = {[id]})

fun lookup id =
    (* haskell style monadic code *)
    ro <- oneOrNoRows (SELECT t.A FROM t WHERE t.Id = {[id]});
    case ro of
        None => return None           (* return is the ''monad'' lifting function *)
      | Some r => return (Some r.T.A)

(* ''check'' called by client side onClick event handler,
               so it will be compiled to JavaScript as page embedded client script *)
fun check ls =
    case ls of
        Nil => return ()
      | Cons (id, ls') =>
            ao <- rpc (lookup id);      (* Ajax call to server side *)
            alert (case ao of
                   None => "Nada"
                 | Some a => a
                 );
            check ls'

fun main () =
    idAdd <- source "";
    aAdd <- source "";

    idDel <- source "";

    (* generates web page with JavaScript inclusions *)
    return <xml><body>
      <button value="Check values of 1, 2, and 3"
              onclick={fn _ => let val mylist = 1 :: 2 :: 3 :: []
                               in
                                  check mylist
                               end
                               }/><br/>
      <br/>
      <button value="Add"
              onclick={fn _ => id <- get idAdd;
                               a <- get aAdd;
                               rpc (add (readError id) a)  (* Ajax call to server side *)
                               }/>
      <ctextbox source={idAdd}/>
      <ctextbox source={aAdd}/><br/>
      <br/>
      <button value="Delete"
              onclick={fn _ => id <- get idDel;
                               rpc (del (readError id))    (* Ajax call to server side *)
                               }/>
      <ctextbox source={idDel}/>
    </body></xml>
</syntaxhighlight>

Project file (.urp extension), must contain an optional directive list followed by a listing of project modules:<ref>{{cite web
 |last1=Chlipala
 |first1=Adam
 |date=January 2015
 |url=https://enn.github.io/urweb-doc/node5.html
 |title=The Ur/Web Manual – Project files
 |publisher=[[GitHub]]
 |access-date=8 January 2015}}</ref>

 ''# 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''

* server side, page retrieving functions with no side effects (http GET method) are accessible through a URL as {{Not a typo|/ModulePath/functionName}}; they should have type ''(unit -> transaction page)''.
* To export a page which may cause side effects, accessible only via HTTP POST, include one argument of the page handler of type ''Basis.postBody''.<ref>[https://enn.github.io/urweb-doc/node54.html The Ur/Web Manual - The Structure of Web Applications]</ref>

Compile:

 urweb module1   ''# looks for module1.urp''
Execute as a web server (other modes are [[Common Gateway Interface|CGI]], [[FastCGI]], ...):
 ./module1.exe -p 8081   ''# -h : RTS options help''

== Libraries ==
* [https://github.com/urweb/urweb/blob/master/lib/ur/basis.urs The predefined API]
* [https://github.com/urweb/urweb/tree/master/lib/ur The standard library]
* [https://github.com/urweb/urweb/tree/master/tests Per feature tests]
* [http://www.impredicative.com/wiki/index.php/Libraries_and_FFI_bindings Ur wiki - Libraries and FFI bindings]

== Special features and problems ==
* Record updating

<syntaxhighlight lang=sml>
datatype mystruc k v = Empty | Node of {Key: k, Value: v}

fun setKey [k][v] (* type polymorphism *)
           (_: ord k) (* implicit instance of class ord *)
           (callerErrNote: string) (k1: k) (my: mystruc k v) : mystruc k v =
   if k1 < kmin
   then error <xml>setKey: illegal k1 {[callerErrNote]}</xml>
   else case my of
             Node r => Node (r -- #Key ++ {Key = k1})
             | _ => error <xml>setKey: not a Node {[callerErrNote]}</xml>
</syntaxhighlight>
corresponding signature (kind annotations (:::) implicit; (::) explicit):
<syntaxhighlight lang=ocaml>
con mystruc :: Type -> Type -> Type    (* two param. type constructor *)

val setKey : k ::: Type -> v ::: Type -> ord k -> string -> k -> mystruc k v -> mystruc k v
</syntaxhighlight>

* Record fields ellipsis
<syntaxhighlight lang=haskell>
  case my of
    Node {Key = k, ...} => doWhatever k
    | _ => ....
</syntaxhighlight>

* Error "Substitution in constructor is blocked by a too-deep unification variable"<ref>[http://www.impredicative.com/pipermail/ur/2011-January/000498.html Unexpected type error: "Substitution in constructor is blocked by a too-deep unification variable"]</ref>

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

== See also ==
* [[Opa (programming language)|Opa]], a language for combined frontend-backend development

== References ==
{{Reflist}}

== External links ==
* {{Official website|impredicative.com/ur}}
* {{GitHub|urweb|Ur/Web}}
* [http://www.impredicative.com/wiki/index.php/Special:AllPages Ur wiki]

{{ML programming}}
{{Haskell programming}}
{{Programming languages}}

[[Category:High-level programming languages]]
[[Category:Functional languages]]
[[Category:ML programming language family]]
[[Category:Haskell programming language family]]
[[Category:Programming languages created in 2014]]
[[Category:Free and open-source software]]
[[Category:Massachusetts Institute of Technology software]]
[[Category:Software using the MIT license]]
<!-- Hidden categories below -->
[[Category:Articles with example Haskell code]]