Ur (lenguaje de programación)

Ur , también llamado Ur/Web , es un lenguaje de programación funcional , puro , estricto y de alto nivel , multiparadigma . Es un dialecto del lenguaje ML , diseñado para el desarrollo web , creado por Adam Chlipala en el Instituto Tecnológico de Massachusetts ^{[ 3 ]} , que permite que un programa genere código para un servidor , un cliente de navegador web y SQL específico para una base de datos determinada . La implementación completa es software libre y de código abierto, publicado bajo la licencia MIT ^{[ 2 ]} .

Ur tiene su origen y raíces en un idioma progenitor superado llamado Laconic/Web , ^{[ 4 ]} en 2006. ^{[ 5 ]}

Ur admite un tipo potente de metaprogramación basado en tipos de datos de fila . ^{[ 2 ]}

Ur/Web es Ur más una biblioteca estándar especial y reglas asociadas para el análisis y la optimización. Ur/Web admite la construcción de páginas web dinámicas y aplicaciones respaldadas por bases de datos SQL . La firma de la biblioteca estándar es tal que los programas Ur/Web bien tipados "no fallan" en un sentido muy amplio. No se bloquean durante la generación de páginas particulares y pueden no: ^{[ 2 ]}

• Sufrir cualquier tipo de ataque de inyección de código
• Devuelve HTML no válido
• Contiene enlaces internos de la aplicación que no funcionan.
• Existen discrepancias entre los formularios HTML y los campos esperados por sus controladores.
• Incluir código del lado del cliente que haga suposiciones incorrectas sobre los servicios de estilo " Ajax " que proporciona el servidor web remoto.
• Intentar realizar consultas SQL no válidas
• Utilice técnicas de serialización o deserialización incorrectas en la comunicación con bases de datos SQL o entre navegadores web y servidores web.

Esta seguridad de tipos es solo la base de la metodología Ur/Web. También es posible utilizar metaprogramación para construir partes importantes de la aplicación mediante el análisis de la estructura de tipos. ^{[ 2 ]}

El compilador Ur/Web también produce código objeto muy eficiente que no utiliza recolección de basura . ^{[ 2 ]}

Las plantillas de sintaxis SQL integradas en el lenguaje facilitan el manejo de tablas.

Aunque la sintaxis se basa en Standard ML, el lenguaje incluye conceptos de Haskell con manipulación de tipos añadida.

La llamada/respuesta Ajax se serializa a través de una mónada llamada transacción (que corresponde a la entrada/salida (IO) de Haskell ) y su serialización y decodificación están encapsuladas en la función rpc .

El lado del cliente del navegador incluye funcionalidades de programación reactiva que utilizan el (source a)tipo y una mónada de señales .

Este es un programa de demostración que muestra el código del cliente, el servidor y la base de datos con comunicación Ajax , de las demostraciones web, ^{[ 7 ]} con comentarios adicionales para describir cada uno de los componentes:

Archivo de interfaz ( firma tipo ML ) con extensión .urs :

(* la mónada de entorno se llama transaction, corresponde a la mónada IO de Haskell *) val main : unit -> transaction page

Archivo de implementación (extensión .ur):

lista de tipos de datos t = Nil | Cons de t * lista ttabla t : { Id : int , A : string } CLAVE PRIMARIA Id(* Acceso a la base de datos del lado del servidor, llamado a través de AJAX XmlHttpRequest  encapsulado como función ''rpc'' (llamada a procedimiento remoto) *) fun add id s = (* Plantilla SQL DML con {[expresión]} *) dml ( INSERT INTO t ( Id , A ) VALUES ({[ id ]}, {[ s ]}))fun del id = dml ( DELETE FROM t WHERE t . Id = {[ id ]})fun lookup id = (* código monádico estilo haskell *) ro <- oneOrNoRows ( SELECT t . A FROM t WHERE t . Id = {[ id ]}); case ro of None => return None (* return es la función de elevación ''mónada'' *) | Some r => return ( Some r . T . A )(* ''check'' llamado por el controlador de eventos onClick del lado del cliente,  por lo que se compilará a JavaScript como script de cliente incrustado en la página *) fun check ls = case ls of Nil => return () | Cons ( id , ls' ) => ao <- rpc ( lookup id ); (* Llamada Ajax al lado del servidor *) alert ( case ao of None => "Nada" | Some a => a ); check ls'diversión principal () = idAdd <- fuente "" ; aAgregar < -fuente "" ;idDel <- origen "" ;(* genera página web con inclusiones de JavaScript *) return <xml><body> <button value = "Comprobar valores de 1, 2 y 3" onclick ={ fn _ => let val mylist = 1 :: 2 :: 3 :: [] in check mylist end } /><br/> <br/> <button value = "Agregar" onclick ={ fn _ => id <- get idAdd ; a <- get aAdd ; rpc ( add ( readError id ) a ) (* Llamada Ajax al lado del servidor *) } /> <ctextbox source ={ idAdd } /> <ctextbox source ={ aAdd } /><br/> <br/> <button value = "Eliminar" onclick ={ fn _ => id <- get idDel ; rpc ( del ( readError id )) (* Llamada Ajax al servidor *) } /> <ctextbox source ={ idDel } /> </body></xml>

El archivo del proyecto (extensión .urp) debe contener una lista de directivas opcional seguida de una lista de módulos del proyecto: ^{[ 8 ]}

# Los comentarios de línea con prefijo hash reescriben la URL Module1/main # Establece la URL raíz en la función Module1/main exe minombredeexe base de datos dbname=test # atributos y parámetros de la base de datos sql noisy.sql

$/list # Módulos de la biblioteca estándar con prefijo "$/" module2 # Si es utilizado por module1, debe precederlo module1 # Módulo principal

• Las funciones de recuperación de páginas del lado del servidor sin efectos secundarios (método http GET) son accesibles a través de una URL como /ModulePath/functionName ; deben tener el tipo (unidad -> página de transacción) .
• Para exportar una página que puede causar efectos secundarios, accesible solo a través de HTTP POST, incluya un argumento del manejador de página de tipo Basis.postBody . ^{[ 9 ]}

Compilar:

urweb module1 # busca module1.urp

Ejecutar como servidor web (otros modos son CGI , FastCGI , ...):

./module1.exe -p 8081 # -h : Ayuda sobre las opciones de RTS

• La API predefinida
• La biblioteca estándar
• Pruebas de características
• Nuestra wiki - Bibliotecas y enlaces FFI

• Actualización de registros

tipo de datos mystruc k v = Vacío | Nodo de { Clave : k , Valor : v }fun setKey [ k ][ v ] (* polimorfismo de tipo *) (_: ord k ) (* instancia implícita de la clase ord *) ( callerErrNote : string ) ( k1 : k ) ( my : mystruc k v ) : mystruc k v = if k1 < kmin then error <xml>setKey : ilegal k1 {[ callerErrNote ]} </xml> else case my of Node r => Node ( r -- #Key ++ { Key = k1 }) | _ => error <xml>setKey : no es un Nodo {[ callerErrNote ]} </xml>

firma correspondiente (anotaciones de tipo (:::) implícitas; (::) explícitas):

con mystruc :: Type -> Type -> Type (* constructor de tipo de dos parámetros *)val setKey : k ::: Tipo -> v ::: Tipo -> ord k -> cadena -> k -> mystruc k v -> mystruc k v

• puntos suspensivos de campos de registro

caso mi de Nodo { Clave = k , ... } => hacerLoQuesea k | _ => ....

• Error "La sustitución en el constructor está bloqueada por una variable de unificación demasiado profunda" ^{[ 10 ]}

Este error se produce con tipos de aridad> 0 en cláusulas caseOR anidadas lety desaparece al anotar el tipo de las variables en las cláusulas anidadas.

• Opa , un lenguaje para el desarrollo combinado de frontend y backend.

• Sitio web oficial
• Ur/Web en GitHub
• Tu wiki archivada el 1 de febrero de 2019 en Wayback Machine.