[Ur] Pb with urblog and new release

Manu chompmotte at yahoo.fr
Tue Jan 12 17:33:35 EST 2010


Adam Chlipala wrote:
> Available as usual at: http://www.impredicative.com/ur/
>
> CHANGELOG for this release:
>
> - Basis.serialized type family, for storing more types in the database
> - Basis.textBlob, for building blobs from strings
> - Basis.debug function, for server-side debug printing
> - Bug fixes & optimization improvements
>
>
> _______________________________________________
> Ur mailing list
> Ur at impredicative.com
> http://www.impredicative.com/cgi-bin/mailman/listinfo/ur
>
Hello

trying to compile gian's urblog (a bit of a personal obsession I must admit)
I get this formidable trace :

editor.ur:94:28-98:60: Expression is not a constructor function
Expression:
foldRX2[[(Type * Type)]] [fst[[Type]][[Type]]] [colMeta] [tr]
 (fn nm :: Name =>
   fn t :: (Type * Type) =>
    fn rest :: {(Type * Type)} =>
     fn v : t.1 =>
      fn col :
       $(([#Show =
            (t.1 -> Basis.xml (([]) ++ [#Body = ()]) ([]) ([]))]) ++
          [#Nam = string,
            #Widget = nm :: Name -> xml form ([]) ([nm = t.2]),
            #WidgetPopulated =
             nm :: Name -> (t.1 -> xml form ([]) ([nm = t.2])),
            #Parse = (t.2 -> t.1), #Inject = sql_injectable t.1]) =>
       Basis.join [([]) ++ [#Body = (), #Tr = ()]] [[]] [[]] [[]]
        (Basis.cdata [([]) ++ [#Body = (), #Tr = ()]] [[]] "\n")
        (Basis.join [([]) ++ [#Body = (), #Tr = ()]] [[]] [[]] [[]]
          (Basis.cdata [([]) ++ [#Body = (), #Tr = ()]] [[]]
            "                                                       ")
          (Basis.join [([]) ++ [#Body = (), #Tr = ()]] [[]] [[]] [[]]
            (Basis.tag [[]]
              [[#Colspan = Basis.int, #Id = Basis.string,
                 #Onblur = Basis.transaction Basis.unit,
                 #Onfocus = Basis.transaction Basis.unit,
                 #Onclick = Basis.transaction Basis.unit,
                 #Ondblclick = Basis.transaction Basis.unit,
                 #Onmousedown = Basis.transaction Basis.unit,
                 #Onmousemove = Basis.transaction Basis.unit,
                 #Onmouseout = Basis.transaction Basis.unit,
                 #Onmouseover = Basis.transaction Basis.unit,
                 #Onmouseup = Basis.transaction Basis.unit,
                 #Onkeydown =
                  (Basis.int -> Basis.transaction Basis.unit),
                 #Onkeypress =
                  (Basis.int -> Basis.transaction Basis.unit),
                 #Onkeyup =
                  (Basis.int -> Basis.transaction Basis.unit)]]
              [([]) ++ [#Body = (), #Tr = ()]] [([]) ++ [#Body = ()]]
              [[]] [[]] [[]] [[]] (Basis.None [Basis.css_class]) {}
              (Basis.td [[]] {}) (col.#Show v))
            (Basis.join [([]) ++ [#Body = (), #Tr = ()]]
              [([]) ++ ([]) ++ []] [[]] [[]]
              (Basis.cdata [([]) ++ [#Body = (), #Tr = ()]]
                [([]) ++ ([]) ++ []] "\n")
              (Basis.cdata [([]) ++ [#Body = (), #Tr = ()]]
                [([]) ++ ([]) ++ []]
                "                                                     ")))))
 [<UNIF:U358::{(Type * Type)}>] _
      Type:
($(map (fn t :: (Type * Type) => t.1) <UNIF:U358::{(Type * Type)}>)
  ->
  ($(map
      (fn t_formT :: (Type * Type) =>
        {Nam : string, Show : (t_formT.1 -> xbody),
          Widget : nm :: Name -> xml form ([]) ([nm = t_formT.2]),
          WidgetPopulated :
           nm :: Name ->
            (t_formT.1 -> xml form ([]) ([nm = t_formT.2])),
          Parse : (t_formT.2 -> t_formT.1),
          Inject : sql_injectable t_formT.1})
      <UNIF:U358::{(Type * Type)}>) ->
    Basis.xml ([#Body = (), #Tr = ()]) ([]) ([])))
editor.ur:110:13-116:27: Expression is not a constructor function
Expression:
foldR[[(Type * Type)]] [colMeta]
 [(fn cols :: {(Type * Type)} =>
    xml form ([]) (map snd[[Type]][[Type]] cols))]
 (fn nm :: Name =>
   fn t :: (Type * Type) =>
    fn rest :: {(Type * Type)} =>
     fn col : colMeta t =>
      fn acc : xml form ([]) (map snd[[Type]][[Type]] rest) =>
       Basis.join [[#Form = (), #Body = ()]] [[]] [[]]
        [(map (fn t :: (Type * Type) => t.2) rest) ++ [nm = t.2]]
        (Basis.cdata [[#Form = (), #Body = ()]] [[]] "\n")
        (Basis.join [[#Form = (), #Body = ()]] [[]] [[]]
          [(map (fn t :: (Type * Type) => t.2) rest) ++ [nm = t.2]]
          (Basis.cdata [[#Form = (), #Body = ()]] [[]]
            "                                      ")
          (Basis.join [[#Form = (), #Body = ()]] [[]] [[]]
            [(map (fn t :: (Type * Type) => t.2) rest) ++ [nm = t.2]]
            (cdata [[#Form = (), #Body = ()]] [[]] col.#Nam)
            (Basis.join [([#Form = ()]) ++ [#Body = ()]] [[]] [[]]
              [(map (fn t :: (Type * Type) => t.2) rest) ++
                [nm = t.2]]
              (Basis.tag [[]] [[#Id = Basis.int]]
                [([#Form = ()]) ++ [#Body = ()]] [[]] [[]] [[]] [[]]
                [[]] (Basis.None [Basis.css_class]) {}
                (Basis.br [[#Form = ()]] {})
                (Basis.cdata [[]] [[]] ""))
              (Basis.join [[#Body = (), #Form = ()]] [[]]
                [[nm = t.2]]
                [map (fn t :: (Type * Type) => t.2) rest]
                (col.#Widget [nm])
                (Basis.join [([#Form = ()]) ++ [#Body = ()]]
                  [[nm = t.2]] [[]]
                  [map (fn t :: (Type * Type) => t.2) rest]
                  (Basis.tag [[]] [[#Id = Basis.int]]
                    [([#Form = ()]) ++ [#Body = ()]] [[]] [[]]
                    [[nm = t.2]] [[]] [[]]
                    (Basis.None [Basis.css_class]) {}
                    (Basis.br [[#Form = ()]] {})
                    (Basis.cdata [[]] [[nm = t.2]] ""))
                  (Basis.join [[#Body = (), #Form = ()]] [[nm = t.2]]
                    [[]] [map (fn t :: (Type * Type) => t.2) rest]
                    (Basis.cdata [[#Body = (), #Form = ()]]
                      [[nm = t.2]] "\n")
                    (Basis.join [[#Body = (), #Form = ()]]
                      [[nm = t.2]] [[]]
                      [map (fn t :: (Type * Type) => t.2) rest]
                      (Basis.cdata [[#Body = (), #Form = ()]]
                        [[nm = t.2]]
                        "                                      ")
                      (Basis.join [[#Body = (), #Form = ()]]
                        [[nm = t.2]]
                        [map (fn t :: (Type * Type) => t.2) rest]
                        [[]]
                        (useMore [[#Body = (), #Form = ()]] [[]]
                          [[nm = t.2]]
                          [map (fn t :: (Type * Type) => t.2) rest]
                          acc)
                        (Basis.join [[#Body = (), #Form = ()]]
                          [(map (fn t :: (Type * Type) => t.2) rest)
                            ++ ([nm = t.2]) ++ []] [[]] [[]]
                          (Basis.cdata [[#Body = (), #Form = ()]]
                            [(map (fn t :: (Type * Type) => t.2) rest)
                              ++ ([nm = t.2]) ++ []] "\n")
                          (Basis.cdata [[#Body = (), #Form = ()]]
                            [(map (fn t :: (Type * Type) => t.2) rest)
                              ++ ([nm = t.2]) ++ []]
                            "                                    
")))))))))))
 (Basis.cdata [[#Body = (), #Form = ()]] [[]] "")
 [<UNIF:U994::{(Type * Type)}>] _
      Type:
($(map
    (fn t_formT :: (Type * Type) =>
      {Nam : string, Show : (t_formT.1 -> xbody),
        Widget : nm :: Name -> xml form ([]) ([nm = t_formT.2]),
        WidgetPopulated :
         nm :: Name ->
          (t_formT.1 -> xml form ([]) ([nm = t_formT.2])),
        Parse : (t_formT.2 -> t_formT.1),
        Inject : sql_injectable t_formT.1})
    <UNIF:U994::{(Type * Type)}>) ->
  Basis.xml ([#Body = (), #Form = ()]) ([])
   (map (fn t :: (Type * Type) => t.2) <UNIF:U994::{(Type * Type)}>))
editor.ur:128:15-132:48: Expression is not a constructor function
Expression:
foldRX[[(Type * Type)]] [colMeta] [tr]
 (fn nm :: Name =>
   fn t :: (Type * Type) =>
    fn rest :: {(Type * Type)} =>
     fn col :
      $(([#Nam = Basis.string]) ++
         [#Show = (t.1 -> xbody),
           #Widget = nm :: Name -> xml form ([]) ([nm = t.2]),
           #WidgetPopulated =
            nm :: Name -> (t.1 -> xml form ([]) ([nm = t.2])),
           #Parse = (t.2 -> t.1), #Inject = sql_injectable t.1]) =>
      Basis.join [([]) ++ [#Body = (), #Tr = ()]] [[]] [[]] [[]]
       (Basis.cdata [([]) ++ [#Body = (), #Tr = ()]] [[]] "\n")
       (Basis.join [([]) ++ [#Body = (), #Tr = ()]] [[]] [[]] [[]]
         (Basis.cdata [([]) ++ [#Body = (), #Tr = ()]] [[]]
           "                                           ")
         (Basis.join [([]) ++ [#Body = (), #Tr = ()]] [[]] [[]] [[]]
           (Basis.tag [[]]
             [[#Colspan = Basis.int, #Id = Basis.string,
                #Onblur = Basis.transaction Basis.unit,
                #Onfocus = Basis.transaction Basis.unit,
                #Onclick = Basis.transaction Basis.unit,
                #Ondblclick = Basis.transaction Basis.unit,
                #Onmousedown = Basis.transaction Basis.unit,
                #Onmousemove = Basis.transaction Basis.unit,
                #Onmouseout = Basis.transaction Basis.unit,
                #Onmouseover = Basis.transaction Basis.unit,
                #Onmouseup = Basis.transaction Basis.unit,
                #Onkeydown =
                 (Basis.int -> Basis.transaction Basis.unit),
                #Onkeypress =
                 (Basis.int -> Basis.transaction Basis.unit),
                #Onkeyup =
                 (Basis.int -> Basis.transaction Basis.unit)]]
             [([]) ++ [#Body = (), #Tr = ()]] [([]) ++ [#Body = ()]]
             [[]] [[]] [[]] [[]] (Basis.None [Basis.css_class]) {}
             (Basis.th [[]] {})
             (cdata [([]) ++ [#Body = ()]] [[]] col.#Nam))
           (Basis.join [([]) ++ [#Body = (), #Tr = ()]] [[]] [[]]
             [[]]
             (Basis.cdata [([]) ++ [#Body = (), #Tr = ()]] [[]] "\n")
             (Basis.cdata [([]) ++ [#Body = (), #Tr = ()]] [[]]
               "                                         ")))))
 [<UNIF:U1624::{(Type * Type)}>] _
      Type:
($(map
    (fn t_formT :: (Type * Type) =>
      {Nam : string, Show : (t_formT.1 -> xbody),
        Widget : nm :: Name -> xml form ([]) ([nm = t_formT.2]),
        WidgetPopulated :
         nm :: Name ->
          (t_formT.1 -> xml form ([]) ([nm = t_formT.2])),
        Parse : (t_formT.2 -> t_formT.1),
        Inject : sql_injectable t_formT.1})
    <UNIF:U1624::{(Type * Type)}>) ->
  Basis.xml ([#Body = (), #Tr = ()]) ([]) ([]))
editor.ur:144:21-150:30: Expression is not a constructor function
Expression:
foldR2[[(Type * Type)]] [snd[[Type]][[Type]]] [colMeta]
 [(fn cols :: {(Type * Type)} =>
    $(map (fn t :: (Type * Type) => sql_exp ([]) ([]) ([]) t.1) cols))]
 (fn nm :: Name =>
   fn t :: (Type * Type) =>
    fn rest :: {(Type * Type)} =>
     fn input : t.2 =>
      fn col :
       $(([#Inject = Basis.sql_injectable t.1]) ++
          ([#Parse = (t.2 -> t.1)]) ++
           [#Nam = string, #Show = (t.1 -> xbody),
             #Widget = nm :: Name -> xml form ([]) ([nm = t.2]),
             #WidgetPopulated =
              nm :: Name -> (t.1 -> xml form ([]) ([nm = t.2]))]) =>
       fn acc :
        $(map (fn t :: (Type * Type) => sql_exp ([]) ([]) ([]) t.1)
           rest) =>
        acc ++
         {nm =
           sql_inject [[]] [[]] [[]] [t.1] col.#Inject
            (col.#Parse input)}) {} [<UNIF:U1858::{(Type * Type)}>] _
      Type:
($(map (fn t :: (Type * Type) => t.2) <UNIF:U1858::{(Type * Type)}>)
  ->
  ($(map
      (fn t_formT :: (Type * Type) =>
        {Nam : string, Show : (t_formT.1 -> xbody),
          Widget : nm :: Name -> xml form ([]) ([nm = t_formT.2]),
          WidgetPopulated :
           nm :: Name ->
            (t_formT.1 -> xml form ([]) ([nm = t_formT.2])),
          Parse : (t_formT.2 -> t_formT.1),
          Inject : sql_injectable t_formT.1})
      <UNIF:U1858::{(Type * Type)}>) ->
    $(map (fn t :: (Type * Type) => Basis.sql_exp ([]) ([]) ([]) t.1)
       <UNIF:U1858::{(Type * Type)}>)))
editor.ur:162:21-162:44: Unification failure
Expression:
update [<UNIF:U2042::{Type}>] [<UNIF:U2043::{{Unit}}>]
 [map fst[[Type]][[Type]] M.cols]
  Have con:
($(map
    (fn v :: (Type * Type) =>
      Basis.sql_exp
       ([#T =
          (map (fn t :: (Type * Type) => t.1) M.cols) ++
           <UNIF:U2042::{Type}>]) ([]) ([])
       ((fn t :: (Type * Type) => t.1) v)) M.cols) ->
  ((Basis.sql_table
     ((map (fn t :: (Type * Type) => t.1) M.cols) ++
       <UNIF:U2042::{Type}>) <UNIF:U2043::{{Unit}}>) ->
    ((Basis.sql_exp
       ([#T =
          (map (fn t :: (Type * Type) => t.1) M.cols) ++
           <UNIF:U2042::{Type}>]) ([]) ([]) Basis.bool) -> Basis.dml)))
  Need con:
[<UNIF:U2044::{<UNIF:U225>}> ~ <UNIF:U2045::{<UNIF:U226>}>] =>
 <UNIF:U2046::Type>
Incompatible constructors
Con 1:
($(map
    (fn v :: (Type * Type) =>
      Basis.sql_exp
       ([#T =
          (map (fn t :: (Type * Type) => t.1) M.cols) ++
           <UNIF:U2042::{Type}>]) ([]) ([])
       ((fn t :: (Type * Type) => t.1) v)) M.cols) ->
  ((Basis.sql_table
     ((map (fn t :: (Type * Type) => t.1) M.cols) ++
       <UNIF:U2042::{Type}>) <UNIF:U2043::{{Unit}}>) ->
    ((Basis.sql_exp
       ([#T =
          (map (fn t :: (Type * Type) => t.1) M.cols) ++
           <UNIF:U2042::{Type}>]) ([]) ([]) Basis.bool) -> Basis.dml)))
Con 2:
[<UNIF:U2044::{<UNIF:U225>}> ~ <UNIF:U2045::{<UNIF:U226>}>] =>
 <UNIF:U2046::Type>
editor.ur:163:29-172:38: Expression is not a constructor function
Expression:
foldR2[[(Type * Type)]] [snd[[Type]][[Type]]] [colMeta]
 [(fn cols :: {(Type * Type)} =>
    $(map
       (fn t :: (Type * Type) =>
         sql_exp
          ([#T = ([#Id = int]) ++ map fst[[Type]][[Type]] M.cols])
          ([]) ([]) t.1) cols))]
 (fn nm :: Name =>
   fn t :: (Type * Type) =>
    fn rest :: {(Type * Type)} =>
     fn input : t.2 =>
      fn col :
       $(([#Inject = Basis.sql_injectable t.1]) ++
          ([#Parse = (t.2 -> t.1)]) ++
           [#Nam = string, #Show = (t.1 -> xbody),
             #Widget = nm :: Name -> xml form ([]) ([nm = t.2]),
             #WidgetPopulated =
              nm :: Name -> (t.1 -> xml form ([]) ([nm = t.2]))]) =>
       fn acc :
        $(map
           (fn t :: (Type * Type) =>
             sql_exp
              ([#T = ([#Id = int]) ++ map fst[[Type]][[Type]] M.cols])
              ([]) ([]) t.1) rest) =>
        acc ++
         {nm =
           sql_inject
            [[#T = ([#Id = int]) ++ map fst[[Type]][[Type]] M.cols]]
            [[]] [[]] [t.1] col.#Inject (col.#Parse input)}) {}
 [<UNIF:U2071::{(Type * Type)}>] _
      Type:
($(map (fn t :: (Type * Type) => t.2) <UNIF:U2071::{(Type * Type)}>)
  ->
  ($(map
      (fn t_formT :: (Type * Type) =>
        {Nam : string, Show : (t_formT.1 -> xbody),
          Widget : nm :: Name -> xml form ([]) ([nm = t_formT.2]),
          WidgetPopulated :
           nm :: Name ->
            (t_formT.1 -> xml form ([]) ([nm = t_formT.2])),
          Parse : (t_formT.2 -> t_formT.1),
          Inject : sql_injectable t_formT.1})
      <UNIF:U2071::{(Type * Type)}>) ->
    $(map
       (fn t :: (Type * Type) =>
         Basis.sql_exp
          ([#T =
             ([#Id = Basis.int]) ++
              map (fn t :: (Type * Type) => t.1) M.cols]) ([]) ([])
          t.1) <UNIF:U2071::{(Type * Type)}>)))
editor.ur:188:17-196:30: Expression is not a constructor function
Expression:
foldR2[[(Type * Type)]] [fst[[Type]][[Type]]] [colMeta]
 [(fn cols :: {(Type * Type)} =>
    xml form ([]) (map snd[[Type]][[Type]] cols))]
 (fn nm :: Name =>
   fn t :: (Type * Type) =>
    fn rest :: {(Type * Type)} =>
     fn v : t.1 =>
      fn col : colMeta t =>
       fn acc : xml form ([]) (map snd[[Type]][[Type]] rest) =>
        Basis.join [[#Form = (), #Body = ()]] [[]] [[]]
         [(map (fn t :: (Type * Type) => t.2) rest) ++ [nm = t.2]]
         (Basis.cdata [[#Form = (), #Body = ()]] [[]] "\n")
         (Basis.join [[#Form = (), #Body = ()]] [[]] [[]]
           [(map (fn t :: (Type * Type) => t.2) rest) ++ [nm = t.2]]
           (Basis.cdata [[#Form = (), #Body = ()]] [[]]
             "                              ")
           (Basis.join [[#Form = (), #Body = ()]] [[]] [[]]
             [(map (fn t :: (Type * Type) => t.2) rest) ++ [nm = t.2]]
             (cdata [[#Form = (), #Body = ()]] [[]] col.#Nam)
             (Basis.join [([#Form = ()]) ++ [#Body = ()]] [[]] [[]]
               [(map (fn t :: (Type * Type) => t.2) rest) ++
                 [nm = t.2]]
               (Basis.tag [[]] [[#Id = Basis.int]]
                 [([#Form = ()]) ++ [#Body = ()]] [[]] [[]] [[]] [[]]
                 [[]] (Basis.None [Basis.css_class]) {}
                 (Basis.br [[#Form = ()]] {})
                 (Basis.cdata [[]] [[]] ""))
               (Basis.join [[#Body = (), #Form = ()]] [[]]
                 [[nm = t.2]]
                 [map (fn t :: (Type * Type) => t.2) rest]
                 (col.#WidgetPopulated [nm] v)
                 (Basis.join [([#Form = ()]) ++ [#Body = ()]]
                   [[nm = t.2]] [[]]
                   [map (fn t :: (Type * Type) => t.2) rest]
                   (Basis.tag [[]] [[#Id = Basis.int]]
                     [([#Form = ()]) ++ [#Body = ()]] [[]] [[]]
                     [[nm = t.2]] [[]] [[]]
                     (Basis.None [Basis.css_class]) {}
                     (Basis.br [[#Form = ()]] {})
                     (Basis.cdata [[]] [[nm = t.2]] ""))
                   (Basis.join [[#Body = (), #Form = ()]]
                     [[nm = t.2]] [[]]
                     [map (fn t :: (Type * Type) => t.2) rest]
                     (Basis.cdata [[#Body = (), #Form = ()]]
                       [[nm = t.2]] "\n")
                     (Basis.join [[#Body = (), #Form = ()]]
                       [[nm = t.2]] [[]]
                       [map (fn t :: (Type * Type) => t.2) rest]
                       (Basis.cdata [[#Body = (), #Form = ()]]
                         [[nm = t.2]]
                         "                              ")
                       (Basis.join [[#Body = (), #Form = ()]]
                         [[nm = t.2]]
                         [map (fn t :: (Type * Type) => t.2) rest]
                         [[]]
                         (useMore [[#Body = (), #Form = ()]] [[]]
                           [[nm = t.2]]
                           [map (fn t :: (Type * Type) => t.2) rest]
                           acc)
                         (Basis.join [[#Body = (), #Form = ()]]
                           [(map (fn t :: (Type * Type) => t.2) rest)
                             ++ ([nm = t.2]) ++ []] [[]] [[]]
                           (Basis.cdata [[#Body = (), #Form = ()]]
                             [(map (fn t :: (Type * Type) => t.2)
                                rest) ++ ([nm = t.2]) ++ []] "\n")
                           (Basis.cdata [[#Body = (), #Form = ()]]
                             [(map (fn t :: (Type * Type) => t.2)
                                rest) ++ ([nm = t.2]) ++ []]
                             "                            ")))))))))))
 (Basis.cdata [[#Body = (), #Form = ()]] [[]] "")
 [<UNIF:U2681::{(Type * Type)}>] _
      Type:
($(map (fn t :: (Type * Type) => t.1) <UNIF:U2681::{(Type * Type)}>)
  ->
  ($(map
      (fn t_formT :: (Type * Type) =>
        {Nam : string, Show : (t_formT.1 -> xbody),
          Widget : nm :: Name -> xml form ([]) ([nm = t_formT.2]),
          WidgetPopulated :
           nm :: Name ->
            (t_formT.1 -> xml form ([]) ([nm = t_formT.2])),
          Parse : (t_formT.2 -> t_formT.1),
          Inject : sql_injectable t_formT.1})
      <UNIF:U2681::{(Type * Type)}>) ->
    Basis.xml ([#Body = (), #Form = ()]) ([])
     (map (fn t :: (Type * Type) => t.2)
       <UNIF:U2681::{(Type * Type)}>)))
manu at chleb:~/Code/Ur/urblog$ rm urblog.exe
manu at chleb:~/Code/Ur/urblog$ urweb urblog
editor.ur:94:28-98:60: Expression is not a constructor function
Expression:
foldRX2[[(Type * Type)]] [fst[[Type]][[Type]]] [colMeta] [tr]
 (fn nm :: Name =>
   fn t :: (Type * Type) =>
    fn rest :: {(Type * Type)} =>
     fn v : t.1 =>
      fn col :
       $(([#Show =
            (t.1 -> Basis.xml (([]) ++ [#Body = ()]) ([]) ([]))]) ++
          [#Nam = string,
            #Widget = nm :: Name -> xml form ([]) ([nm = t.2]),
            #WidgetPopulated =
             nm :: Name -> (t.1 -> xml form ([]) ([nm = t.2])),
            #Parse = (t.2 -> t.1), #Inject = sql_injectable t.1]) =>
       Basis.join [([]) ++ [#Body = (), #Tr = ()]] [[]] [[]] [[]]
        (Basis.cdata [([]) ++ [#Body = (), #Tr = ()]] [[]] "\n")
        (Basis.join [([]) ++ [#Body = (), #Tr = ()]] [[]] [[]] [[]]
          (Basis.cdata [([]) ++ [#Body = (), #Tr = ()]] [[]]
            "                                                       ")
          (Basis.join [([]) ++ [#Body = (), #Tr = ()]] [[]] [[]] [[]]
            (Basis.tag [[]]
              [[#Colspan = Basis.int, #Id = Basis.string,
                 #Onblur = Basis.transaction Basis.unit,
                 #Onfocus = Basis.transaction Basis.unit,
                 #Onclick = Basis.transaction Basis.unit,
                 #Ondblclick = Basis.transaction Basis.unit,
                 #Onmousedown = Basis.transaction Basis.unit,
                 #Onmousemove = Basis.transaction Basis.unit,
                 #Onmouseout = Basis.transaction Basis.unit,
                 #Onmouseover = Basis.transaction Basis.unit,
                 #Onmouseup = Basis.transaction Basis.unit,
                 #Onkeydown =
                  (Basis.int -> Basis.transaction Basis.unit),
                 #Onkeypress =
                  (Basis.int -> Basis.transaction Basis.unit),
                 #Onkeyup =
                  (Basis.int -> Basis.transaction Basis.unit)]]
              [([]) ++ [#Body = (), #Tr = ()]] [([]) ++ [#Body = ()]]
              [[]] [[]] [[]] [[]] (Basis.None [Basis.css_class]) {}
              (Basis.td [[]] {}) (col.#Show v))
            (Basis.join [([]) ++ [#Body = (), #Tr = ()]]
              [([]) ++ ([]) ++ []] [[]] [[]]
              (Basis.cdata [([]) ++ [#Body = (), #Tr = ()]]
                [([]) ++ ([]) ++ []] "\n")
              (Basis.cdata [([]) ++ [#Body = (), #Tr = ()]]
                [([]) ++ ([]) ++ []]
                "                                                     ")))))
 [<UNIF:U358::{(Type * Type)}>] _
      Type:
($(map (fn t :: (Type * Type) => t.1) <UNIF:U358::{(Type * Type)}>)
  ->
  ($(map
      (fn t_formT :: (Type * Type) =>
        {Nam : string, Show : (t_formT.1 -> xbody),
          Widget : nm :: Name -> xml form ([]) ([nm = t_formT.2]),
          WidgetPopulated :
           nm :: Name ->
            (t_formT.1 -> xml form ([]) ([nm = t_formT.2])),
          Parse : (t_formT.2 -> t_formT.1),
          Inject : sql_injectable t_formT.1})
      <UNIF:U358::{(Type * Type)}>) ->
    Basis.xml ([#Body = (), #Tr = ()]) ([]) ([])))
editor.ur:110:13-116:27: Expression is not a constructor function
Expression:
foldR[[(Type * Type)]] [colMeta]
 [(fn cols :: {(Type * Type)} =>
    xml form ([]) (map snd[[Type]][[Type]] cols))]
 (fn nm :: Name =>
   fn t :: (Type * Type) =>
    fn rest :: {(Type * Type)} =>
     fn col : colMeta t =>
      fn acc : xml form ([]) (map snd[[Type]][[Type]] rest) =>
       Basis.join [[#Form = (), #Body = ()]] [[]] [[]]
        [(map (fn t :: (Type * Type) => t.2) rest) ++ [nm = t.2]]
        (Basis.cdata [[#Form = (), #Body = ()]] [[]] "\n")
        (Basis.join [[#Form = (), #Body = ()]] [[]] [[]]
          [(map (fn t :: (Type * Type) => t.2) rest) ++ [nm = t.2]]
          (Basis.cdata [[#Form = (), #Body = ()]] [[]]
            "                                      ")
          (Basis.join [[#Form = (), #Body = ()]] [[]] [[]]
            [(map (fn t :: (Type * Type) => t.2) rest) ++ [nm = t.2]]
            (cdata [[#Form = (), #Body = ()]] [[]] col.#Nam)
            (Basis.join [([#Form = ()]) ++ [#Body = ()]] [[]] [[]]
              [(map (fn t :: (Type * Type) => t.2) rest) ++
                [nm = t.2]]
              (Basis.tag [[]] [[#Id = Basis.int]]
                [([#Form = ()]) ++ [#Body = ()]] [[]] [[]] [[]] [[]]
                [[]] (Basis.None [Basis.css_class]) {}
                (Basis.br [[#Form = ()]] {})
                (Basis.cdata [[]] [[]] ""))
              (Basis.join [[#Body = (), #Form = ()]] [[]]
                [[nm = t.2]]
                [map (fn t :: (Type * Type) => t.2) rest]
                (col.#Widget [nm])
                (Basis.join [([#Form = ()]) ++ [#Body = ()]]
                  [[nm = t.2]] [[]]
                  [map (fn t :: (Type * Type) => t.2) rest]
                  (Basis.tag [[]] [[#Id = Basis.int]]
                    [([#Form = ()]) ++ [#Body = ()]] [[]] [[]]
                    [[nm = t.2]] [[]] [[]]
                    (Basis.None [Basis.css_class]) {}
                    (Basis.br [[#Form = ()]] {})
                    (Basis.cdata [[]] [[nm = t.2]] ""))
                  (Basis.join [[#Body = (), #Form = ()]] [[nm = t.2]]
                    [[]] [map (fn t :: (Type * Type) => t.2) rest]
                    (Basis.cdata [[#Body = (), #Form = ()]]
                      [[nm = t.2]] "\n")
                    (Basis.join [[#Body = (), #Form = ()]]
                      [[nm = t.2]] [[]]
                      [map (fn t :: (Type * Type) => t.2) rest]
                      (Basis.cdata [[#Body = (), #Form = ()]]
                        [[nm = t.2]]
                        "                                      ")
                      (Basis.join [[#Body = (), #Form = ()]]
                        [[nm = t.2]]
                        [map (fn t :: (Type * Type) => t.2) rest]
                        [[]]
                        (useMore [[#Body = (), #Form = ()]] [[]]
                          [[nm = t.2]]
                          [map (fn t :: (Type * Type) => t.2) rest]
                          acc)
                        (Basis.join [[#Body = (), #Form = ()]]
                          [(map (fn t :: (Type * Type) => t.2) rest)
                            ++ ([nm = t.2]) ++ []] [[]] [[]]
                          (Basis.cdata [[#Body = (), #Form = ()]]
                            [(map (fn t :: (Type * Type) => t.2) rest)
                              ++ ([nm = t.2]) ++ []] "\n")
                          (Basis.cdata [[#Body = (), #Form = ()]]
                            [(map (fn t :: (Type * Type) => t.2) rest)
                              ++ ([nm = t.2]) ++ []]
                            "                                    
")))))))))))
 (Basis.cdata [[#Body = (), #Form = ()]] [[]] "")
 [<UNIF:U994::{(Type * Type)}>] _
      Type:
($(map
    (fn t_formT :: (Type * Type) =>
      {Nam : string, Show : (t_formT.1 -> xbody),
        Widget : nm :: Name -> xml form ([]) ([nm = t_formT.2]),
        WidgetPopulated :
         nm :: Name ->
          (t_formT.1 -> xml form ([]) ([nm = t_formT.2])),
        Parse : (t_formT.2 -> t_formT.1),
        Inject : sql_injectable t_formT.1})
    <UNIF:U994::{(Type * Type)}>) ->
  Basis.xml ([#Body = (), #Form = ()]) ([])
   (map (fn t :: (Type * Type) => t.2) <UNIF:U994::{(Type * Type)}>))
editor.ur:128:15-132:48: Expression is not a constructor function
Expression:
foldRX[[(Type * Type)]] [colMeta] [tr]
 (fn nm :: Name =>
   fn t :: (Type * Type) =>
    fn rest :: {(Type * Type)} =>
     fn col :
      $(([#Nam = Basis.string]) ++
         [#Show = (t.1 -> xbody),
           #Widget = nm :: Name -> xml form ([]) ([nm = t.2]),
           #WidgetPopulated =
            nm :: Name -> (t.1 -> xml form ([]) ([nm = t.2])),
           #Parse = (t.2 -> t.1), #Inject = sql_injectable t.1]) =>
      Basis.join [([]) ++ [#Body = (), #Tr = ()]] [[]] [[]] [[]]
       (Basis.cdata [([]) ++ [#Body = (), #Tr = ()]] [[]] "\n")
       (Basis.join [([]) ++ [#Body = (), #Tr = ()]] [[]] [[]] [[]]
         (Basis.cdata [([]) ++ [#Body = (), #Tr = ()]] [[]]
           "                                           ")
         (Basis.join [([]) ++ [#Body = (), #Tr = ()]] [[]] [[]] [[]]
           (Basis.tag [[]]
             [[#Colspan = Basis.int, #Id = Basis.string,
                #Onblur = Basis.transaction Basis.unit,
                #Onfocus = Basis.transaction Basis.unit,
                #Onclick = Basis.transaction Basis.unit,
                #Ondblclick = Basis.transaction Basis.unit,
                #Onmousedown = Basis.transaction Basis.unit,
                #Onmousemove = Basis.transaction Basis.unit,
                #Onmouseout = Basis.transaction Basis.unit,
                #Onmouseover = Basis.transaction Basis.unit,
                #Onmouseup = Basis.transaction Basis.unit,
                #Onkeydown =
                 (Basis.int -> Basis.transaction Basis.unit),
                #Onkeypress =
                 (Basis.int -> Basis.transaction Basis.unit),
                #Onkeyup =
                 (Basis.int -> Basis.transaction Basis.unit)]]
             [([]) ++ [#Body = (), #Tr = ()]] [([]) ++ [#Body = ()]]
             [[]] [[]] [[]] [[]] (Basis.None [Basis.css_class]) {}
             (Basis.th [[]] {})
             (cdata [([]) ++ [#Body = ()]] [[]] col.#Nam))
           (Basis.join [([]) ++ [#Body = (), #Tr = ()]] [[]] [[]]
             [[]]
             (Basis.cdata [([]) ++ [#Body = (), #Tr = ()]] [[]] "\n")
             (Basis.cdata [([]) ++ [#Body = (), #Tr = ()]] [[]]
               "                                         ")))))
 [<UNIF:U1624::{(Type * Type)}>] _
      Type:
($(map
    (fn t_formT :: (Type * Type) =>
      {Nam : string, Show : (t_formT.1 -> xbody),
        Widget : nm :: Name -> xml form ([]) ([nm = t_formT.2]),
        WidgetPopulated :
         nm :: Name ->
          (t_formT.1 -> xml form ([]) ([nm = t_formT.2])),
        Parse : (t_formT.2 -> t_formT.1),
        Inject : sql_injectable t_formT.1})
    <UNIF:U1624::{(Type * Type)}>) ->
  Basis.xml ([#Body = (), #Tr = ()]) ([]) ([]))
editor.ur:144:21-150:30: Expression is not a constructor function
Expression:
foldR2[[(Type * Type)]] [snd[[Type]][[Type]]] [colMeta]
 [(fn cols :: {(Type * Type)} =>
    $(map (fn t :: (Type * Type) => sql_exp ([]) ([]) ([]) t.1) cols))]
 (fn nm :: Name =>
   fn t :: (Type * Type) =>
    fn rest :: {(Type * Type)} =>
     fn input : t.2 =>
      fn col :
       $(([#Inject = Basis.sql_injectable t.1]) ++
          ([#Parse = (t.2 -> t.1)]) ++
           [#Nam = string, #Show = (t.1 -> xbody),
             #Widget = nm :: Name -> xml form ([]) ([nm = t.2]),
             #WidgetPopulated =
              nm :: Name -> (t.1 -> xml form ([]) ([nm = t.2]))]) =>
       fn acc :
        $(map (fn t :: (Type * Type) => sql_exp ([]) ([]) ([]) t.1)
           rest) =>
        acc ++
         {nm =
           sql_inject [[]] [[]] [[]] [t.1] col.#Inject
            (col.#Parse input)}) {} [<UNIF:U1858::{(Type * Type)}>] _
      Type:
($(map (fn t :: (Type * Type) => t.2) <UNIF:U1858::{(Type * Type)}>)
  ->
  ($(map
      (fn t_formT :: (Type * Type) =>
        {Nam : string, Show : (t_formT.1 -> xbody),
          Widget : nm :: Name -> xml form ([]) ([nm = t_formT.2]),
          WidgetPopulated :
           nm :: Name ->
            (t_formT.1 -> xml form ([]) ([nm = t_formT.2])),
          Parse : (t_formT.2 -> t_formT.1),
          Inject : sql_injectable t_formT.1})
      <UNIF:U1858::{(Type * Type)}>) ->
    $(map (fn t :: (Type * Type) => Basis.sql_exp ([]) ([]) ([]) t.1)
       <UNIF:U1858::{(Type * Type)}>)))
editor.ur:162:21-162:44: Unification failure
Expression:
update [<UNIF:U2042::{Type}>] [<UNIF:U2043::{{Unit}}>]
 [map fst[[Type]][[Type]] M.cols]
  Have con:
($(map
    (fn v :: (Type * Type) =>
      Basis.sql_exp
       ([#T =
          (map (fn t :: (Type * Type) => t.1) M.cols) ++
           <UNIF:U2042::{Type}>]) ([]) ([])
       ((fn t :: (Type * Type) => t.1) v)) M.cols) ->
  ((Basis.sql_table
     ((map (fn t :: (Type * Type) => t.1) M.cols) ++
       <UNIF:U2042::{Type}>) <UNIF:U2043::{{Unit}}>) ->
    ((Basis.sql_exp
       ([#T =
          (map (fn t :: (Type * Type) => t.1) M.cols) ++
           <UNIF:U2042::{Type}>]) ([]) ([]) Basis.bool) -> Basis.dml)))
  Need con:
[<UNIF:U2044::{<UNIF:U225>}> ~ <UNIF:U2045::{<UNIF:U226>}>] =>
 <UNIF:U2046::Type>
Incompatible constructors
Con 1:
($(map
    (fn v :: (Type * Type) =>
      Basis.sql_exp
       ([#T =
          (map (fn t :: (Type * Type) => t.1) M.cols) ++
           <UNIF:U2042::{Type}>]) ([]) ([])
       ((fn t :: (Type * Type) => t.1) v)) M.cols) ->
  ((Basis.sql_table
     ((map (fn t :: (Type * Type) => t.1) M.cols) ++
       <UNIF:U2042::{Type}>) <UNIF:U2043::{{Unit}}>) ->
    ((Basis.sql_exp
       ([#T =
          (map (fn t :: (Type * Type) => t.1) M.cols) ++
           <UNIF:U2042::{Type}>]) ([]) ([]) Basis.bool) -> Basis.dml)))
Con 2:
[<UNIF:U2044::{<UNIF:U225>}> ~ <UNIF:U2045::{<UNIF:U226>}>] =>
 <UNIF:U2046::Type>
editor.ur:163:29-172:38: Expression is not a constructor function
Expression:
foldR2[[(Type * Type)]] [snd[[Type]][[Type]]] [colMeta]
 [(fn cols :: {(Type * Type)} =>
    $(map
       (fn t :: (Type * Type) =>
         sql_exp
          ([#T = ([#Id = int]) ++ map fst[[Type]][[Type]] M.cols])
          ([]) ([]) t.1) cols))]
 (fn nm :: Name =>
   fn t :: (Type * Type) =>
    fn rest :: {(Type * Type)} =>
     fn input : t.2 =>
      fn col :
       $(([#Inject = Basis.sql_injectable t.1]) ++
          ([#Parse = (t.2 -> t.1)]) ++
           [#Nam = string, #Show = (t.1 -> xbody),
             #Widget = nm :: Name -> xml form ([]) ([nm = t.2]),
             #WidgetPopulated =
              nm :: Name -> (t.1 -> xml form ([]) ([nm = t.2]))]) =>
       fn acc :
        $(map
           (fn t :: (Type * Type) =>
             sql_exp
              ([#T = ([#Id = int]) ++ map fst[[Type]][[Type]] M.cols])
              ([]) ([]) t.1) rest) =>
        acc ++
         {nm =
           sql_inject
            [[#T = ([#Id = int]) ++ map fst[[Type]][[Type]] M.cols]]
            [[]] [[]] [t.1] col.#Inject (col.#Parse input)}) {}
 [<UNIF:U2071::{(Type * Type)}>] _
      Type:
($(map (fn t :: (Type * Type) => t.2) <UNIF:U2071::{(Type * Type)}>)
  ->
  ($(map
      (fn t_formT :: (Type * Type) =>
        {Nam : string, Show : (t_formT.1 -> xbody),
          Widget : nm :: Name -> xml form ([]) ([nm = t_formT.2]),
          WidgetPopulated :
           nm :: Name ->
            (t_formT.1 -> xml form ([]) ([nm = t_formT.2])),
          Parse : (t_formT.2 -> t_formT.1),
          Inject : sql_injectable t_formT.1})
      <UNIF:U2071::{(Type * Type)}>) ->
    $(map
       (fn t :: (Type * Type) =>
         Basis.sql_exp
          ([#T =
             ([#Id = Basis.int]) ++
              map (fn t :: (Type * Type) => t.1) M.cols]) ([]) ([])
          t.1) <UNIF:U2071::{(Type * Type)}>)))
editor.ur:188:17-196:30: Expression is not a constructor function
Expression:
foldR2[[(Type * Type)]] [fst[[Type]][[Type]]] [colMeta]
 [(fn cols :: {(Type * Type)} =>
    xml form ([]) (map snd[[Type]][[Type]] cols))]
 (fn nm :: Name =>
   fn t :: (Type * Type) =>
    fn rest :: {(Type * Type)} =>
     fn v : t.1 =>
      fn col : colMeta t =>
       fn acc : xml form ([]) (map snd[[Type]][[Type]] rest) =>
        Basis.join [[#Form = (), #Body = ()]] [[]] [[]]
         [(map (fn t :: (Type * Type) => t.2) rest) ++ [nm = t.2]]
         (Basis.cdata [[#Form = (), #Body = ()]] [[]] "\n")
         (Basis.join [[#Form = (), #Body = ()]] [[]] [[]]
           [(map (fn t :: (Type * Type) => t.2) rest) ++ [nm = t.2]]
           (Basis.cdata [[#Form = (), #Body = ()]] [[]]
             "                              ")
           (Basis.join [[#Form = (), #Body = ()]] [[]] [[]]
             [(map (fn t :: (Type * Type) => t.2) rest) ++ [nm = t.2]]
             (cdata [[#Form = (), #Body = ()]] [[]] col.#Nam)
             (Basis.join [([#Form = ()]) ++ [#Body = ()]] [[]] [[]]
               [(map (fn t :: (Type * Type) => t.2) rest) ++
                 [nm = t.2]]
               (Basis.tag [[]] [[#Id = Basis.int]]
                 [([#Form = ()]) ++ [#Body = ()]] [[]] [[]] [[]] [[]]
                 [[]] (Basis.None [Basis.css_class]) {}
                 (Basis.br [[#Form = ()]] {})
                 (Basis.cdata [[]] [[]] ""))
               (Basis.join [[#Body = (), #Form = ()]] [[]]
                 [[nm = t.2]]
                 [map (fn t :: (Type * Type) => t.2) rest]
                 (col.#WidgetPopulated [nm] v)
                 (Basis.join [([#Form = ()]) ++ [#Body = ()]]
                   [[nm = t.2]] [[]]
                   [map (fn t :: (Type * Type) => t.2) rest]
                   (Basis.tag [[]] [[#Id = Basis.int]]
                     [([#Form = ()]) ++ [#Body = ()]] [[]] [[]]
                     [[nm = t.2]] [[]] [[]]
                     (Basis.None [Basis.css_class]) {}
                     (Basis.br [[#Form = ()]] {})
                     (Basis.cdata [[]] [[nm = t.2]] ""))
                   (Basis.join [[#Body = (), #Form = ()]]
                     [[nm = t.2]] [[]]
                     [map (fn t :: (Type * Type) => t.2) rest]
                     (Basis.cdata [[#Body = (), #Form = ()]]
                       [[nm = t.2]] "\n")
                     (Basis.join [[#Body = (), #Form = ()]]
                       [[nm = t.2]] [[]]
                       [map (fn t :: (Type * Type) => t.2) rest]
                       (Basis.cdata [[#Body = (), #Form = ()]]
                         [[nm = t.2]]
                         "                              ")
                       (Basis.join [[#Body = (), #Form = ()]]
                         [[nm = t.2]]
                         [map (fn t :: (Type * Type) => t.2) rest]
                         [[]]
                         (useMore [[#Body = (), #Form = ()]] [[]]
                           [[nm = t.2]]
                           [map (fn t :: (Type * Type) => t.2) rest]
                           acc)
                         (Basis.join [[#Body = (), #Form = ()]]
                           [(map (fn t :: (Type * Type) => t.2) rest)
                             ++ ([nm = t.2]) ++ []] [[]] [[]]
                           (Basis.cdata [[#Body = (), #Form = ()]]
                             [(map (fn t :: (Type * Type) => t.2)
                                rest) ++ ([nm = t.2]) ++ []] "\n")
                           (Basis.cdata [[#Body = (), #Form = ()]]
                             [(map (fn t :: (Type * Type) => t.2)
                                rest) ++ ([nm = t.2]) ++ []]
                             "                            ")))))))))))
 (Basis.cdata [[#Body = (), #Form = ()]] [[]] "")
 [<UNIF:U2681::{(Type * Type)}>] _
      Type:
($(map (fn t :: (Type * Type) => t.1) <UNIF:U2681::{(Type * Type)}>)
  ->
  ($(map
      (fn t_formT :: (Type * Type) =>
        {Nam : string, Show : (t_formT.1 -> xbody),
          Widget : nm :: Name -> xml form ([]) ([nm = t_formT.2]),
          WidgetPopulated :
           nm :: Name ->
            (t_formT.1 -> xml form ([]) ([nm = t_formT.2])),
          Parse : (t_formT.2 -> t_formT.1),
          Inject : sql_injectable t_formT.1})
      <UNIF:U2681::{(Type * Type)}>) ->
    Basis.xml ([#Body = (), #Form = ()]) ([])
     (map (fn t :: (Type * Type) => t.2)
       <UNIF:U2681::{(Type * Type)}>)))




it compiled fine with the previous release... what is the cause of this 
error ?

editor.ur can be found here: 
http://github.com/gian/urblog/raw/master/editor.ur
it is based on some of Ur's website demo

Manu




More information about the Ur mailing list