HSP(Haskell Server Pages)

1
HSP(Haskell Server Pages)

• Alejandro del Real Chicharro
• José Emilio Villena Irigoyen

2
Índice

• Introducción
• La función page
• La sintaxis de HSP
• HJavaScript
• HSP Foro Web
• Conclusiones
• Futuros Trabajos
• Bibliografía

3
Introducción

• No hace mucho tiempo, la World Wide Web estaba
  formada casi exclusivamente de páginas estáticas.
  Hoy, sin embargo, el uso de páginas dinámicas en
  la Web se ha incrementado hasta tal punto de
  necesitar mejores herramientas para la creación
  de éstas.
• Los programadores comienzan a usar algunos
  lenguajes script especializados que permiten
  mezclar XML con código, p.e. PHP, ASP o también
  puedan usar CGI.
• La mayoría de los lenguajes compartían los
  mismos defectos, y algunos hasta varios de estos.
  Ellos modelaban texto HTML como texto sin
  formato, y esto violaba uno de los principios de
  abstracción de Tennent.

4
Introducción

• Se busca un lenguaje funcional que soporte un
  modelo de programación completo y la facilidad de
  uso de un lenguaje script especializado, mientras
  aún mantenga el gran potencial de XML.
• En el 2000, Erik Meijer y Danny van Velzen
  presentaron lo que ellos llamaron como Haskell
  Server Pages (HSP), un lenguaje de programación
  Web de dominio específico, basado en la
  funcionalidad de la programación del lenguaje
  Haskell.
• Introduciendo un nuevo tipo de datos data XML que
  garantizaba la correcta formación de páginas
  dinámicas y una mejor integración de XML con
  otros códigos.
• Permitir a los programadores usar fragmentos de
  sintaxis XML en código Haskell, y viceversa,
  permitir embeber expresiones Haskell dentro de
  fragmentos XML.

5
Introducción
Sacamos el bucle para hacer la página más
ordenada.
Código ASP ltTABLE border1gt lt For x
1 To 16 gt ltTRgt lt For y 1 To
16 gt ltTD bicolor lt genColor(x,y) gtgt
(lt x gt,lt y
gt) lt/TDgt lt Next gt lt/TRgt
lt Next gt lt/TABLEgt
6
Introducción
El problema es que ASP no permite esto.
Código ASP ltTABLE border1gt lt For x
1 To 16 gt ltTRgt lt Call GenData
(x) gt lt/TRgt lt Next gt lt/TABLEgt
Tendríamos que ejecutarlo dentro de un módulo de
Visual Basic.
lt Sub GenData(x) For y 1
To 16 Response.Write ltTD
bgcolor Response.Write genColor(x,y)
Response.Write gt Response.Write ( x
, y ) Response.Write lt/TDgt
Next End Sub gt
lt Sub GenData(x) gt lt For y 1 To 16
gt ltTDgt (lt x gt,lt y
gt) lt/TDgt lt Next gt lt End Subgt
7
Introducción
Código en Haskell table TABLE table
ltTABLE border1gt lt mkRows cells
gt lt/TABLEgt cells (Int, Int) cells
(x,y) x? 1..16 y? 1..16
mkRows (Int, Int) ? TR mkRows
map \cs ? ltTRgtlt mkColumns cs
gtlt/TRgt mkColums (Int,Int)
gtTD mkColums map \c ? ltTD bgcolor
(genColor c)gt lt c gt lt/TDgt
Está todo más estructurado.
Es una función asociativa por la derecha para
la eliminación de paréntesis
8
Introducción

• A parte de las extensiones puramente sintácticas,
  HSP también facilita un modelo de programación
  con tipos de datos, clases y funciones que ayuden
  con algunas tareas de la programación Web.
• Por ejemplo
• Mantener el estado de los usuarios en
  transacciones usando sesiones.
• Mantener el estado de aplicaciones entre
  transacciones con diferentes usuarios.
• Acceder a consultas de datos y variables de
  entorno

9
La función page

• Para generar una completa aplicación de páginas
  HSP, necesitamos definir la función page. De
  forma análoga a la función main de Haskell.
• la función page es llamada cuando una página HSP
  es requerida.

page ltHTMLgt ltHEADgt ltTITLEgtHola
Mundo!lt/TITLEgt lt/HEADgt lt/HTMLgt
10
La función page
Páginas XML y páginas Híbridas

• Como un documento válido XML (o bien XHTML) es
  también una de las fuentes principales de los
  programas HSP, necesitamos construir páginas que
  nos permitan utilizar la potencia de XML junto
  con el lenguaje Haskell.
• Por ejemplo un trozo de código en XML que muestra
  un reloj con la hora de cuando un página fue
  pedida sería

ltHTMLgt ltHEADgtltTITLEgtPágina XMLlt/TITLEgtlt/HEADgt
ltBODYgt ltH1gtHola mundo!lt/H1gt ltPgtPágina pedida
con lt getSystemTime gtlt/Pgt lt/BODYgt lt/HTMLgt
11
La función page
Páginas XML y páginas Híbridas

• Y el mismo código ya aplicado a una página HSP
  sería

page ltHTMLgt ltHEADgtltTITLEgtPágina
XMLlt/TITLEgtlt/HEADgt ltBODYgt ltH1gtHola
mundo!lt/H1gt ltPgtPágina pedida con lt
getSystemTime gtlt/Pgt lt/BODYgt lt/HTMLgt
Aunque hay un ligero problema con estas páginas.
La función getSystemTime reside en el modulo
System.Time, el cuál necesita ser importado para
que la función sea usada.
12
La función page
Páginas XML y páginas Híbridas

• Con HSP no habría problemas pero con pero en
  páginas XML no hay ningún lugar donde poder
  añadir la importación.
• Para salvar este problema se introducen las
  páginas híbridas que contienen una combinación de
  páginas XML con un nivel alto de declaraciones.

lt import System.Time gt ltHTMLgt
ltHEADgtltTITLEgtPágina XML lt/TITLEgtlt/HEADgt
ltBODYgt ltH1gtHola mundo!lt/H1gt ltPgtPágina
demandada lt getSystemTime gtlt/Pgt
lt/BODYgt lt/HTMLgt
13
La función page
Sintaxis formal de una página

• Para poder crear páginas híbridas se añade una
  nueva función más elaborada de page,
  especificando como una página correcta en HSP,
  puede parecerse a

page module xml
lt module gt xml

• Podemos utilizar un módulo normal de HSP, un
  árbol completo XML, o bien una combinación de los
  dos.

14
La función page
Computación embebida y mónada HSP

• Cuál es el tipo de la función de nuestro ejemplo
  hola mundo?
• Solución más simple Dejar el tipo XML
• Pero no es tan sencillo, porque permitimos
  cálculos impuros
• cálculos con efectos laterales para ser embebidos
  dentro de los fragmentos de XML.
• Ejemplo de computación embebida getSystemTime
  con el tipo IO Time

15
La función page
Computación embebida y mónada HSP

• HSP suspende la computación embebida hasta que es
  evaluada explícitamente
• Parece que las funciones devuelven valores XML
  puros, pero pueden contener computaciones no
  evaluadas
• No hay forma de distinguir entre valores XML
  puros y los que contienen computaciones no
  evaluadas

16
La función page
Computación embebida y mónada HSP

• Para solucionar esto se introdujo una mónada HSP
• Encapsula los efectos laterales
• Proporciona entorno E/S a las páginas Web
• Todas las expresiones XML serán resueltas
  computando una mónada HSP.
• Ejemplo
• ltpgt Hola mundo!lt/pgt
• Tiene tipo HSP XML a pesar de no tener efectos
  laterales

No es algo perfecto, pero es preferible a no
tener efectos laterales nunca
17
Sintaxis HSP

• Encuentro entre XML y Haskell
• HolaMundol ltpgtHola Mundo!lt/pgt
• Hay dos cosas interesantes que comentar
• No necesitamos usar ningún mecanismo de escape
  para dejar el contexto del código cuando queremos
  escribir el fragmente XML,
• en HSP todos los fragmentos XML están
  garantizados para estar siempre bien-formados.

18
Sintaxis HSP

• Las expresiones malformadas darían error
• helloWorld ltpgtHello World!lt/qgt
• Las etiquetas funcionan ellas solas cómo escapes
• boldHelloWorld ltpgtltbgtHello World!lt/bgtlt/pgt
• Siempre que queramos que el contenido interno sea
  evaluado por una expresión, deberemos usar
  caracteres de escape
• hello name ltpgtHello lt name gt!lt/pgt

19
Sintaxis HSP

• Queremos también que nuestros elementos XML sean
  capaces de tener atributos
• RedHelloWorld HSP XML
• redHelloWorld
• ltp style"colorred"gtHello World!lt/pgt
• Al igual que los hijos, los valores de atributos
  pueden también ser computados a partir de
  expresiones embebidas
• hwColor String -gt HSP XML
• hwColor c
• ltp style("color" c)gtHello World!lt/pgt

20
Sintaxis HSP

• Todas las páginas HSP deben definir y exportar
  una página de función definiendo el contenido de
  la página.
• page lthtmlgt
• ltheadgtlttitlegtHello World!lt/titlegtlt/headgt
• lt helloBody gt
• lt/htmlgt

Ya tenemos nuestra primera página HSP!!!
21
Sintaxis HSP - Concordancia de patrones

• Concordancia de Elementos
• Lo primero de todo lo que podemos comparar
  directamente en elementos, cómo
• isImg ltimg/gt True
• isImg _ False
• Nuestra interpretación intuitiva de lo de arriba
  es que implementa isImg devolverá True si un
  elemento img se da, y False en otro caso

22
Sintaxis HSP - Concordancia de patrones

• Concordancia de Atributos
• Para concordancia de patrones en atributos,
  primero necesitamos considerar cómo queremos
  usarlos. Lo primero de todo, en XML el orden de
  atributos es irrelevante, por lo que para la
  instancia de dos elementos
• ltimg src"img/myImg.jpg" alt"My image" /gt
• y,
• ltimg alt"My image" src"img/myImg.jpg" /gt

Son equivalentes!
23
Sintaxis HSP - Concordancia de patrones

• Concordancia de Hijos
• La concordancia de patrones en hijos se puede
  escribir cómo en este ejemplo
• getPText ltpgtlt PCDATA t gtlt/pgt t
• Comparar un simple hijo es bastante simple, pero
  para ejemplos más complicados existe un problema
• comparar un número arbitrario de elementos ltpgt
• o
• empezar por comparar un elemento lth1gt, seguido
  por uno o más ocurrencias de un elemento lth2gt y
  un elemento ltpgt en la secuencia

24
Sintaxis HSP - Concordancia de patrones

• Para esto hemos desarrollado HaRP (Haskell
  Regular Patterns). El sistema para patrones de
  expresiones regulares en Haskell
• Ejemplo para obtener todo el texto de los
  párrafos de un documento
• getText XML -gt String
• getText ltbodygt
• ltpgtlt PCDATA t gtlt/pgt
• lt/bodygt t

Denota que debería haber 0 o más p encerrados en
el elemento body
25
Sintaxis HSP Sintaxis formal

• Sintaxis formal
• Extendemos la gramática Haskell con nuevas
  producciones de expresiones XML, las cuales
  añadimos al lenguaje cómo una expresión atómica
  posible
• aexp var
• lit
• ( exp )
• ...
• xml
• La nueva manera de expresión, xml, puede ser
  también un elemento cerrado con hijos, o una
  etiqueta vacía auto-contenida
• xml ltname attrsgtchild...childlt/namegt
• ltname attrs/gt

26
Sintaxis HSP Sintaxis formal

• Los atributos son pares nombre-valor, seguidos
  opcionalmente por una expresión extra
• attrs attrs1 aexp
• attrs1
• attrs1 name aexp ... name aexp
• Un hijo puede ser un elemento jerarquizado,
  PCDATA o una expresión Haskell embebida
• child xml
• PCDATA
• lt exp gt

27
Sintaxis HSP Sintaxis formal

• Un nombre en XML puede ser calificado
  opcionalmente por un espacio de nombres a cuyo
  elemento pertenece. Nuestra producción de nombre
  queda así
• name string string
• string
• donde el espacio de nombres definido
  anteriormente está especificado

28
Sintaxis HSP Entorno

• Las páginas HSP tienen acceso a un entorno
  especial que contiene información si tenemos en
  cuenta el contexto en el cual son evaluadas.
• Los componentes principales son
• Petición Peticiones HTTP que iniciaron la
  llamada a la página
• Respuesta Respuesta HTTP que ha sido generada,
  la cual se enviará con los resultados de la
  llamada a la página
• Aplicación Contiene datos con visibilidad de
  aplicación, por ejemplo datos que persisten entre
  transacciones de páginas
• Sesión Contiene datos que pertenecen a un
  cliente específico

29
Sintaxis HSP Entorno

• Entorno de Petición
• ASP
• Request (hello)
• PHP
• _REQUESThello
• HSP
• getParameter hello

30
Sintaxis HSP Entorno

• En el entorno del programación lo más importante
  es consultar cadenas de caracteres (pares
  nombre-valor) de la forma
• param1 valor1paramn valorn
• Los parámetros en la petición pueden ser
  accedidos usando las funciones
• getParameter String -gt HSP (Maybe String)
• readParameter Read a gt String -gt HSP (Maybe
  a)

31
Sintaxis HSP Entorno

• Entorno de Respuesta
• Los componentes de respuesta almacenan cabeceras
  que serán enviadas de vuelta al cliente receptor
  con los contenidos de los documentos. Estos son
  conjuntos que usan funciones especializadas cómo
• setNoCache HSP ()
• En HSP ninguna salida debería ser añadida a la
  respuesta manualmente, todos los contenidos
  deberían estar generados por la función de
  página, garantizando la correcta formación del
  XML generado
• Por ejemplo, no sería correcto
• ltpgtHola lt Response.write(nombre) gtlt/pgt

miMensaje String-gt HSP XML miMensaje nombre
ltpgtHola lt nombre gtlt/pgt
32
Sintaxis HSP Entorno

• Entorno de Aplicación
• El componente de Aplicación contiene datos que
  están compartiendo entre todas las páginas de una
  aplicación, y que persiste entre peticiones
  simples a páginas
• El tipo de Aplicación es por si mismo abstracto,
  por lo que la única manera de crear un valor del
  tipo que está usando la aplicación es
• toApplication (Typeable a) gt a -gt Application

33
Sintaxis HSP Entorno

• El entorno de Aplicación es actualmente un tipo
  de envoltorio (Wrapper) dinámico, el cual es
  usado para habilitar al componente de la
  Aplicación ser de cualquier tipo
• newtype Application
• MkApp appContents Dynamic
• toApplication MkApp . toDynamic
• Para acceder a los datos de aplicación de dentro
  de una página, un programador puede usar la
  función
• getApplication (Typeable a) gt HSP a
• que devuelve un valor de su particular tipo de
  Aplicación

34
Sintaxis HSP Entorno

• Ejemplo (un contador)
• Queremos actualizar los valores del contador
  necesitamos almacenarlo en una referencia
• Type MyApplication Mvar Int
• Ponemos estas declaraciones en un módulo que
  llamamos MiAplicacion.hs y añadimos
• toMyApplication MyApplication -gt
  Application
• toMyApplication toApplication
• getMyApplication HSP MyApplication
• getMyApplication getApplication

35
Sintaxis HSP Entorno

• Función para incrementar el contador
• incrContador HSP ()
• incrContador do
• ctr lt- getMyApplication
• doIO modifyMVar ctr (1)
• Función para leer el valor actual del contador
• leerContador HSP Int
• leerContador do
• ctr lt- getMyApplication
• doIO readMVar ctr

36
Sintaxis HSP Entorno

• Ya sólo queda darle un valor inicial al contador
• En el modulo Aplicación.hsp primeramente hemos de
  importar MiAplicacion.hs, y la definición
• initApplication do
• ctr lt- newMVar 0
• return toMyApplication ctr

37
Sintaxis HSP Entorno

• La página
• import MiAplicacion
• page do
• incrementarContador
• lthtmlgt
• ltheadgt
• lttitlegtHola visitante nr lt
• leerContador gt
• lt/titlegt
• lt/headgt
• ltbodygt
• lth1gtHola!lt/h1gt
• ltpgtEres el visitante nr lt
• leerContador gt de esta página.
• lt/pgt
• lt/bodygt
• lt/htmlgt

38
Sintaxis HSP Entorno

• Entorno de Sesión
• Los componentes de Sesión son un repositorio de
  datos que deja a las páginas mantener un estado
  entre transacciones
• Acceso al repositorio
• getSessionVar String -gt HSP (Maybe String)
• setSessionVar String -gt String -gt HSP ()
• Configurar tiempo de vida
• setSessionExpires ClockTime -gt HSP ()
• Forzando su terminación
• abandon HSP ()

almacenados en el lado del cliente usando cookies
39
HJavaScript

• Surgen la necesidad de un lenguaje script que
  pueda dar funcionalidad a nuestras páginas del
  lado del cliente
• HJScript se ha desarrollado con dos metas
• Proveer al programador una sintaxis lo más
  abstracta posible
• Proveer una sintaxis cómo la original
  (JavaScript)

Obviamente esto no es posible
40
HJavaScript

• Para modelar un lenguaje imperativo vamos a
  trabajar con una mónada
• La mónada será escritora-estado
• Parte escritora Usada para el código JavaScript
  a la salida
• Parte estado Usada para la gestión del gensym

41
HJavaScript

• Las 2 funciones básicas en la mónada, aparte de
  devolver y registrar son
• newVarName HJScript String
• newVarName do s lt- get
• put s1
• return var show s
• outputCode JsStmt () -gt HJScript ()
• outputCode tell

42
HJavaScript

• También necesitamos una función evaluadora que
  genere el código de salida
• hjscript HJScript t -gt HJState -gt (t,
  JSBlock ())
• hjscript script s runWriter runStateT
  script s
• y una función que nos deja evaluar una
  computación dentro de otra
• hjsInside HJScript t -gt HJScript (t, JSBlock
  ())
• hjsInside script censor (const EmptyBlock)
  listen script

43
HJavaScript

• Sintaxis
• Para declarar una variable
• nombreVar lt- var
• nombreVar lt- varWith valorInicial
• Para declarar una función
• function (a,b)
• return ab
• function \(a,b) -gt
• return (ab)

En JavaScript
En HJavaScript
44
HJavaScript

• Elección de un símbolo operador
• Así para invocar funciones en HJavaScript
  podremos hacerlo así
• call myFunction (a,b)
• O bien así
• myFunction(a,b)

45
HJavaScript

• Usar métodos de objetos en JavaScript
• Math.abs(n)
• d.getYear()
• En HJavaScript sería
• Mathabs(n)
• dgetYear()

46
HJavaScript

• Para integrar HJavaScript con el resto de HSP
  necesitamos escribir instancias para IsXML y
  IsAttrValue
• IsXML es necesario para
• Ejecutar un script cuando la página se carga
• Definir funciones en la sección de cabecera
• IsAttrValue es necesario para
• Atributos de eventos onClick, onEvent,

47
HJavaScript

• Instancia isXML
• instance IsXML (JsBlock ()) where
• toXML b
• ltscript languageJavaScriptgt
• lt pprBlock b gt
• lt/scriptgt
• Instancia isAttrValue
• instance IsAttrValue (JsBlock ()) where
• toAttrValue b toAttrValue pprBlock b

48
Foro en HSP

• Diseño del foro
• Foro organizado en hilos
• Cada hilo consta de uno o más mensajes
• Cada mensaje consta de
• Texto
• Quién lo escribió
• Cuándo lo escribió

49
Foro en HSP

• Configuraremos una base de datos
• Inicialmente suponemos que podemos acceder a la
  base de datos
• Empezaremos desarrollando un foro muy simple en
  el que sólo se muestre un mensaje, y lo iremos
  ampliando gradualmente

50
Foro en HSP

• Definición de registros
• data Hilo Hilo
• tema String,
• mensajes Mensaje
• data Mensaje Mensaje
• autor, contenido String,
• fecha CalenderTime

51
Foro en HSP

• Para mostrar un mensaje
• mostrarMensaje Mensaje -gt XML
• Información del mensaje grabado en si mismo
• o bien
• mostrarMensaje Mensaje -gt HSP XML
• Información extra de otras fuentes

52
Foro en HSP

• Nos quedamos con la segunda opción
• mostrarMensaje Mensaje-gt HSP XML
• mostrarMensaje mensaje
• ltfieldsetgt
• ltlegendgt
• ltbgtlt mensajeautor gtlt/bgt
• ltigtlt mensajefecha gtlt/igt
• lt/legendgt
• lt nl2br mensajecontenido gt
• lt/fieldsetgt

53
Foro en HSP

• Se mostraría algo así

54
Foro en HSP

• Para simplificar el foro, esta será la manera por
  defecto de mostrar un mensaje
• instance IsXML Mensaje where
• toXML mostrarMensaje
• Ahora vamos a definir una función para mostrar un
  hilo entero
• Asumimos que todos los hilos contienen al menos
  un mensaje
• Colocamos cada mensaje debajo del siguiente

55
Foro en HSP

• Función que muestra un hilo
• mostrarHilo Hilo -gt HSP XML
• mostrarHilo hilo do
• let disposicionMensajes foldl1 () map
  block hilomensajes
• enlacePrincipal aLink indice.hsp
  Volver al índice
• toXML h1 (hilotema) enlacePrincipal
  disposicionMensajes enlacePrincipal

Es un combinador que coloca cualquier objeto
en disposición vertical.
56
Foro en HSP

• Código de mostrarHilo.hsp
• import HSP Forum.Databases (getThread)
• import HSP.Layout
• pagina do mthid lt- getParameter threaded
• case mthid of
• Nothing -gt redirect indice.hsp
• Just thId -gt do
• mthread lt- darHilo thId
• case mthread of
• Nothing -gt redirect indice.hsp
• Just hilo -gt paginaHilo hilo
• paginaHilo hilo
• lthtmlgt
• ltheadgtlttitlegtlt hilotema gtlt/titlegt
• ltbodygtlt mostrarHilo hilo gtlt/bodygt
• lt/htmlgt
• mostrarHilo hilo ...

57
Foro en HSP

• Quedaría algo así

58
Foro en HSP

• Ahora vamos a definir la página índice de los
  hilos
• Necesitamos recuperar la id de los hilos y la
  línea del tema para todos los mensajes
• Dar formato a los pares ltid,temagt en un enlace
  que nos llevará al hilo.
• Listar todos los enlaces

59
Foro en HSP

• Función para crear un enlace a un tema
• enlaceHilo Int -gt String -gt HSP XML
• enlaceHilo threaded
• aLink (mostrarHilo.hsp?idHilo show
  threaded)
• Función para listar los hilos
• listaHilos (Int, String) -gt HSP XML
• listaHilos hilos ul map (uncurry
  enlaceHilo) hilos

60
Foro en HSP

• La página dinámica resultante
• page do mthinfo lt- darInformacionHilo
• let thinfo maybe id mthinfo
• lthtmlgt
• ltheadgtlttitlegtlt nombreForo gtlt/titlegtlt/headgt
• ltbodygt
• lt h1 nombreForo gt
• lt listaHilos thinfo gt
• lt/bodygt
• lt/htmlgt

61
Foro en HSP

• Conexiones a la base de datos
• HaskellDB
• Hay problemas con accesos concurrentes
• Asegurar que sólo hay un recurso de conexión
• Implementar un mecanismo para controlar quién y
  cuándo lo usa

62
Foro en HSP

• Creamos un módulo llamado MiAplicacion.hs donde
  definimos
• type ConexionBD (Database -gt IO a) -gt IO a
• type MiAplicacion (Mvar (),ConexionBD)
• myToApplication MyApplication -gt Application
• myToApplication toApplication
• myGetApplication HSP MyApplication
• myGetApplication toApplication

63
Foro en HSP

• Definimos dos funciones para trabajar sobre las
  conexiones
• conexionBD (Database -gt IO a) -gt HSP a
• conexionBD q do (_, conn) lt- myGetApplication
• doIO conn q
• conexionBDsegura (Database -gt IO a) -gt HSP a
• conexionBDsegura q do (lock, conn) lt-
  myGetApplication
• doIO bracket_
• (takeMVar lock)
• (putMVar lock ())
• (conn q)

Asegura que el programa no se pare si se produce
una excepción
64
Foro en HSP

• Nos queda instalar el fichero Aplicacion.hs
• initApplication do lock lt- newMVar ()
• return myToApplication (lock, conn)
• Asumimos que conn está definido en otra parte, no
  lo veremos en el futuro dado que HaskellDB es muy
  dependiente del sistema de bases de datos usado.

65
Foro en HSP

• Para obtener todos los mensajes de un hilo
  particular
• darHilo Int -gt HSP (Maybe Hilo)
• darHilo idHilo do
• r1 lt- conexionBD \db -gt query db
  consultaHilos
• case r1 of
• -gt return Nothing -- No existe el hilo
• rec -gt do
• r2 lt- conexionBD \db -gt query db
  consultaMensajes
• return Hilo tema rec!Th.tema,
• mensajes map
  hacerMensaje r2
• where consultaHilos do
• t lt- table Th.hilos
• restrict (t!Th. idHilo.. constant idHilo)
• return t
• consultaMensajes do
• t lt- table Th.mensajes
• restrict (t!Th. idHilo.. constant idHilo)
• order asc t Th.mensajeNr

66
Foro en HSP

• Función para almacenar hilos en su tabla
  correspondiente
• darInformacionHilo HSP (Int, String)
• darInformacionHilo do
• r1 lt- conexionBD \db -gt query db (table
  Th.hilo)
• return map (\rec -gt (rec!Th.idHilo,
  rec!Th.tema)) r1
• Creando/Enviando nuevos mensajes
• Comenzar un nuevo hilo o responder a un hilo
  existente
• Responder a un hilo se hará en una página aparte
• Visualizar mensajes tras enviarlos
• Introducimos una página intermedia entre la
  página de envío y la página que muestra los datos

67
Foro en HSP

• Página intermedia
• page do
• thId, autor, contenidos, tema lt-
• mapM getParameter idHilo,
  autor,contenidos, tema
• ti lt- case thId of
• Just thId -gt do
• conexionBDsegura insertPost autor
  contenidos thId
• return thId
• Nothing -gt do
• conexionBDsegura
• insertarHiloDeMensajes tema autor
  mensaje
• redirect mostrarHilo.hsp?idHilo show ti
• where insertarMensaje autor conts thid \db -gt
  do
• let (Just aut, Just txt) (autor, conts)
• time lt- getCurrentTime

68
Foro en HSP

• insert db Th.posts (Th.idHilo ltlt thId
• Th.autor ltlt autor
• Th.fecha ltlt time
• Th.contenido ltlt txt )
• insertarHiloDeMensajes tema autor conts \db
  -gt do
• let (Just aut, Just txt) (autor, conts)
• time lt- getCurrentTime
• insert db Th.hilos (Th.tema ltlt tema)
• rThId lt- query db maxThidConsulta
• let thId rThId!Th.idHilo
• insert db Th.mensajes (Th.idHilo ltlt thId
• Th.autor ltlt autor
• Th.fecha ltlt fecha
• Th.contenido ltlt txt )
• maxThidConsulta do
• t lt- table Th.hilos
• preoject (Th.idHilo ltlt max t!Th.idHilo)

69
Foro en HSP

• Formulario para enviar Mensaje
• formularioMensaje (Maybe Int) -gt HSP XML
• formularioMensaje mthreadId
• ltform methodPost actionhandledata.hspgt
• lt borderTable 0
• filaDelTema
• filaAutor,
• filaContenido,
• idHiloOculto, botonEnvio
• gt
• lt/formgt

70
Foro en HSP

• where filaDelTema
• case mthreadId of
• Just _ -gt
• Nothing -gt withLabel textField tema
• filaAutor withLabel textField autor
• filaContenido withLabel textArea contenido
• idHiloOculto fmap (hidden idHilo) mthreadId
• botonEnvio submit Enviar set
• value Submit post
• Definimos la función withLabel
• withLabel (String -gt HSP XML) -gt String -gt
  HSP XML
• withLabel f n_at_(ccs)
• label n (toUpper c cs ) , f n

71
Foro en HSP

• Para incluir el formulario con hilos, necesitamos
  retocar ligeramente el código para asegurar que
  tenemos acceso al id del hilo
• paginaHilo hilo idHilo
• lthtmlgt
• ltheadgtlttitlegtlt hilotema gtlt/titlegtlt/headgt
• ltbodygt
• lt mostrarHilo hilo
• formularioMensaje (Just idHilo) gt
• lt/bodygt
• lt/htmlgt

72
Foro en HSP

• La página dedicada a comenzar los hilos,
  comenzarHilo.hsp, será
• import formularioMensaje
• page lthtmlgt
• ltheadgtlttitlegtNuevo Hilolt/titlegtlt/headgt
• ltbodygtlt formularioMensaje Nothing gtlt/bodygt
• lt/htmlgt

73
Conclusiones

• La utilización de la potencia de un lenguaje
  funcional como es Haskell junto con la
  simplicidad de la utilización de un lenguaje
  script han hecho de HSP un lenguaje tan bueno
  como sus iguales.
• El área donde debemos realizar mayores esfuerzos
  para mejorar el lenguaje es en la construcción de
  librerías, donde los otros lenguajes tienen mayor
  ventaja.
• La meta inicial en la construcción del diseño del
  lenguaje HSP era que tuviera el mismo poder
  expresivo que Haskell para atraer al programador
  funcional experto, y además fuera muy intuitivo
  para el programador Web novato.
• El problema de que no esté muy extendido es que
  necesita de una comunidad activa que ayude con
  extensiones y mejoras, como librerías, manuales y
  programas de ejemplos.

74
Futuros trabajos

• El modelo de programación presentado define la
  sintaxis y la semántica de la extensión XML a
  Haskell. Pero hay algunas extensiones que podrían
  introducirse para simplificar la forma de
  expresar con certeza algunos modismos.
• Una extensión que vendría conveniente cuando los
  patrones enlacen elementos es permitir resumir el
  nombre del elemento en la sintaxis XML concreta.
• Otra posible extensión es permitir una forma de
  búsqueda de atributo que tendrá éxito
  independientemente de la existencia del atributo
  o no.

75
Futuros trabajos

• Otra cosa a tener en cuenta, es la
  implementación, ya que ésta proporciona una
  completa funcionalidad al sistema HSP.
• Una solución al horrible mensaje de error que
  aparece en el pre-procesador sintáctico puro,
  antes de comprobar los tipos es extender el
  pre-proceso con un analizador de tipos que pueda
  manejar nuestra sintaxis XML tan bien como el
  código Haskell incluido en todas las extensiones
  que HSP usa.
• Crear numerosos documentos de ayuda en pdf, y
  conseguir desarrollar un gran número de librerías
  para conexiones a bases de datos.

76
Bibliografía
Documentos y libros

• Erik Meijer. Server-side Web Scripting in
  Haskell. Journal of Functional Programming, 1(1),
  1998.
• Erik Meijer and Mark Shields. XM? A Functional
  Language for Constructing and Manipulating XML
  Documents. (Draft), 1999.
• Paul Graunke, Shriram Krishnamurthi, Steve Van
  der Hoeven and Matthias Felleisen. Programming
  the Web with High-level Programming Languages. In
  Proceedings of the European Symposium On
  Programming, 2001.
• Erik Meijer and Danny van Velzen. Haskell Server
  Pages Functional Programming and the Battle for
  the Middle Tier. In Proceedings of the Haskell
  Workshop, 2000.
• Ruiz, B.C., Gutierrez, F., Guerrero, P.,
  Gallardo, J.E. Razonando con Haskell. Una
  introducción a la Programación Funcional. Los
  autores. 2000
• Broberg, Niklas. Thesis for the Degree of Master
  of Science.Haskell Server Pages (DRAFT) Chalmers
  University of Technology 2005

77
Bibliografía

• ASP.NET home. http//msdn.microsoft.com/asp.net/.
• PHP Hypertext Processor home. http//www.php.net/
  .
• WASH home.http//www.informatik.uni-freiburg.de/t
  hiemann/haskell/WASH/.
• Extensible Markup Language. http//www.w3c.org/XML
  .

Buscadores científicos
GOOGLE Scholar. http//scholar.google.com/
SCIRUS. Buscador de ciencia. http//www.scirus.com
/srsapp/ Buscador de publicaciones científicas y
de páginas Web de contenido científico.