summaryrefslogtreecommitdiff
path: root/lib
diff options
context:
space:
mode:
authorGravatar Adam Chlipala <adamc@hcoop.net>2009-05-28 10:16:50 -0400
committerGravatar Adam Chlipala <adamc@hcoop.net>2009-05-28 10:16:50 -0400
commit3cb644caeed50e5c82778b5ed7c165950655109a (patch)
tree2173bd760a25b12356629888a84ae960f9c1dd80 /lib
parentd8801e05ef2f81f21eb27555b626ee2e52c3365f (diff)
fn-pattern code in but not tested yet; hello compiles
Diffstat (limited to 'lib')
-rw-r--r--lib/ur/list.ur26
-rw-r--r--lib/ur/list.urs5
-rw-r--r--lib/ur/top.ur90
3 files changed, 76 insertions, 45 deletions
diff --git a/lib/ur/list.ur b/lib/ur/list.ur
index 7527362d..90729f5c 100644
--- a/lib/ur/list.ur
+++ b/lib/ur/list.ur
@@ -83,3 +83,29 @@ fun filter (a ::: Type) f =
in
fil []
end
+
+fun exists (a ::: Type) f =
+ let
+ fun ex ls =
+ case ls of
+ [] => False
+ | x :: ls =>
+ if f x then
+ True
+ else
+ ex ls
+ in
+ ex
+ end
+
+fun foldlMap (a ::: Type) (b ::: Type) (c ::: Type) f =
+ let
+ fun fold ls' st ls =
+ case ls of
+ [] => (rev ls', st)
+ | x :: ls =>
+ case f x st of
+ (y, st) => fold (y :: ls') st ls
+ in
+ fold []
+ end
diff --git a/lib/ur/list.urs b/lib/ur/list.urs
index fb3407ae..28f08317 100644
--- a/lib/ur/list.urs
+++ b/lib/ur/list.urs
@@ -18,3 +18,8 @@ val mapM : m ::: (Type -> Type) -> monad m -> a ::: Type -> b ::: Type
-> (a -> m b) -> list a -> m (list b)
val filter : a ::: Type -> (a -> bool) -> t a -> t a
+
+val exists : a ::: Type -> (a -> bool) -> t a -> bool
+
+val foldlMap : a ::: Type -> b ::: Type -> c ::: Type
+ -> (a -> b -> c * b) -> b -> t a -> t c * b
diff --git a/lib/ur/top.ur b/lib/ur/top.ur
index f9b3d033..785a9c8c 100644
--- a/lib/ur/top.ur
+++ b/lib/ur/top.ur
@@ -6,44 +6,44 @@ con folder = K ==> fn r :: {K} =>
tf r -> tf ([nm = v] ++ r))
-> tf [] -> tf r
-fun fold K (tf :: {K} -> Type)
+fun fold [K] [tf :: {K} -> Type]
(f : (nm :: Name -> v :: K -> r :: {K} -> [[nm] ~ r] =>
tf r -> tf ([nm = v] ++ r)))
- (i : tf []) (r :: {K}) (fl : folder r) = fl [tf] f i
+ (i : tf []) [r :: {K}] (fl : folder r) = fl [tf] f i
structure Folder = struct
- fun nil K (tf :: {K} -> Type)
+ fun nil [K] [tf :: {K} -> Type]
(f : nm :: Name -> v :: K -> r :: {K} -> [[nm] ~ r] =>
tf r -> tf ([nm = v] ++ r))
(i : tf []) = i
- fun cons K (r ::: {K}) (nm :: Name) (v :: K) [[nm] ~ r] (fold : folder r)
- (tf :: {K} -> Type)
+ fun cons [K] [r ::: {K}] [nm :: Name] [v :: K] [[nm] ~ r] (fold : folder r)
+ [tf :: {K} -> Type]
(f : nm :: Name -> v :: K -> r :: {K} -> [[nm] ~ r] =>
tf r -> tf ([nm = v] ++ r))
(i : tf []) = f [nm] [v] [r] ! (fold [tf] f i)
- fun concat K (r1 ::: {K}) (r2 ::: {K}) [r1 ~ r2]
+ fun concat [K] [r1 ::: {K}] [r2 ::: {K}] [r1 ~ r2]
(f1 : folder r1) (f2 : folder r2)
- (tf :: {K} -> Type)
+ [tf :: {K} -> Type]
(f : nm :: Name -> v :: K -> r :: {K} -> [[nm] ~ r] =>
tf r -> tf ([nm = v] ++ r))
(i : tf []) =
f1 [fn r1' => [r1' ~ r2] => tf (r1' ++ r2)]
- (fn (nm :: Name) (v :: K) (r1' :: {K}) [[nm] ~ r1']
+ (fn [nm :: Name] [v :: K] [r1' :: {K}] [[nm] ~ r1']
(acc : [r1' ~ r2] => tf (r1' ++ r2))
[[nm = v] ++ r1' ~ r2] =>
f [nm] [v] [r1' ++ r2] ! acc)
(fn [[] ~ r2] => f2 [tf] f i) !
- fun mp K1 K2 (f ::: K1 -> K2) (r ::: {K1})
+ fun mp [K1] [K2] [f ::: K1 -> K2] [r ::: {K1}]
(fold : folder r)
- (tf :: {K2} -> Type)
+ [tf :: {K2} -> Type]
(f : nm :: Name -> v :: K2 -> r :: {K2} -> [[nm] ~ r] =>
tf r -> tf ([nm = v] ++ r))
(i : tf []) =
fold [fn r => tf (map f r)]
- (fn (nm :: Name) (v :: K1) (rest :: {K1}) [[nm] ~ rest] (acc : tf (map f rest)) =>
+ (fn [nm :: Name] [v :: K1] [rest :: {K1}] [[nm] ~ rest] (acc : tf (map f rest)) =>
f [nm] [f v] [map f rest] ! acc)
i
end
@@ -64,20 +64,20 @@ con mapU = K ==> fn f :: K => map (fn _ :: Unit => f)
con ex = fn tf :: (Type -> Type) =>
res ::: Type -> (choice :: Type -> tf choice -> res) -> res
-fun ex (tf :: (Type -> Type)) (choice :: Type) (body : tf choice) : ex tf =
- fn (res ::: Type) (f : choice :: Type -> tf choice -> res) =>
+fun ex [tf :: (Type -> Type)] [choice :: Type] (body : tf choice) : ex tf =
+ fn [res] (f : choice :: Type -> tf choice -> res) =>
f [choice] body
-fun compose (t1 ::: Type) (t2 ::: Type) (t3 ::: Type)
+fun compose [t1 ::: Type] [t2 ::: Type] [t3 ::: Type]
(f1 : t2 -> t3) (f2 : t1 -> t2) (x : t1) = f1 (f2 x)
-fun show_option (t ::: Type) (_ : show t) =
+fun show_option [t ::: Type] (_ : show t) =
mkShow (fn opt : option t =>
case opt of
None => ""
| Some x => show x)
-fun read_option (t ::: Type) (_ : read t) =
+fun read_option [t ::: Type] (_ : read t) =
mkRead (fn s =>
case s of
"" => None
@@ -89,79 +89,79 @@ fun read_option (t ::: Type) (_ : read t) =
None => None
| v => Some v)
-fun txt (t ::: Type) (ctx ::: {Unit}) (use ::: {Type}) (_ : show t) (v : t) =
+fun txt [t] [ctx ::: {Unit}] [use ::: {Type}] (_ : show t) (v : t) =
cdata (show v)
-fun foldUR (tf :: Type) (tr :: {Unit} -> Type)
+fun foldUR [tf :: Type] [tr :: {Unit} -> Type]
(f : nm :: Name -> rest :: {Unit}
-> [[nm] ~ rest] =>
tf -> tr rest -> tr ([nm] ++ rest))
- (i : tr []) (r :: {Unit}) (fl : folder r)=
+ (i : tr []) [r :: {Unit}] (fl : folder r)=
fl [fn r :: {Unit} => $(mapU tf r) -> tr r]
- (fn (nm :: Name) (t :: Unit) (rest :: {Unit}) [[nm] ~ rest] acc r =>
+ (fn [nm :: Name] [t :: Unit] [rest :: {Unit}] [[nm] ~ rest] acc r =>
f [nm] [rest] ! r.nm (acc (r -- nm)))
(fn _ => i)
-fun foldUR2 (tf1 :: Type) (tf2 :: Type) (tr :: {Unit} -> Type)
+fun foldUR2 [tf1 :: Type] [tf2 :: Type] [tr :: {Unit} -> Type]
(f : nm :: Name -> rest :: {Unit}
-> [[nm] ~ rest] =>
tf1 -> tf2 -> tr rest -> tr ([nm] ++ rest))
- (i : tr []) (r :: {Unit}) (fl : folder r) =
+ (i : tr []) [r :: {Unit}] (fl : folder r) =
fl [fn r :: {Unit} => $(mapU tf1 r) -> $(mapU tf2 r) -> tr r]
- (fn (nm :: Name) (t :: Unit) (rest :: {Unit}) [[nm] ~ rest] acc r1 r2 =>
+ (fn [nm :: Name] [t :: Unit] [rest :: {Unit}] [[nm] ~ rest] acc r1 r2 =>
f [nm] [rest] ! r1.nm r2.nm (acc (r1 -- nm) (r2 -- nm)))
(fn _ _ => i)
-fun foldURX2 (tf1 :: Type) (tf2 :: Type) (ctx :: {Unit})
+fun foldURX2 [tf1 :: Type] [tf2 :: Type] [ctx :: {Unit}]
(f : nm :: Name -> rest :: {Unit}
-> [[nm] ~ rest] =>
tf1 -> tf2 -> xml ctx [] []) =
foldUR2 [tf1] [tf2] [fn _ => xml ctx [] []]
- (fn (nm :: Name) (rest :: {Unit}) [[nm] ~ rest] v1 v2 acc =>
+ (fn [nm :: Name] [rest :: {Unit}] [[nm] ~ rest] v1 v2 acc =>
<xml>{f [nm] [rest] ! v1 v2}{acc}</xml>)
<xml/>
-fun foldR K (tf :: K -> Type) (tr :: {K} -> Type)
+fun foldR [K] [tf :: K -> Type] [tr :: {K} -> Type]
(f : nm :: Name -> t :: K -> rest :: {K}
-> [[nm] ~ rest] =>
tf t -> tr rest -> tr ([nm = t] ++ rest))
- (i : tr []) (r :: {K}) (fl : folder r) =
+ (i : tr []) [r :: {K}] (fl : folder r) =
fl [fn r :: {K} => $(map tf r) -> tr r]
- (fn (nm :: Name) (t :: K) (rest :: {K}) [[nm] ~ rest] (acc : _ -> tr rest) r =>
+ (fn [nm :: Name] [t :: K] [rest :: {K}] [[nm] ~ rest] (acc : _ -> tr rest) r =>
f [nm] [t] [rest] ! r.nm (acc (r -- nm)))
(fn _ => i)
-fun foldR2 K (tf1 :: K -> Type) (tf2 :: K -> Type) (tr :: {K} -> Type)
+fun foldR2 [K] [tf1 :: K -> Type] [tf2 :: K -> Type] [tr :: {K} -> Type]
(f : nm :: Name -> t :: K -> rest :: {K}
-> [[nm] ~ rest] =>
tf1 t -> tf2 t -> tr rest -> tr ([nm = t] ++ rest))
- (i : tr []) (r :: {K}) (fl : folder r) =
+ (i : tr []) [r :: {K}] (fl : folder r) =
fl [fn r :: {K} => $(map tf1 r) -> $(map tf2 r) -> tr r]
- (fn (nm :: Name) (t :: K) (rest :: {K}) [[nm] ~ rest]
+ (fn [nm :: Name] [t :: K] [rest :: {K}] [[nm] ~ rest]
(acc : _ -> _ -> tr rest) r1 r2 =>
f [nm] [t] [rest] ! r1.nm r2.nm (acc (r1 -- nm) (r2 -- nm)))
(fn _ _ => i)
-fun foldRX K (tf :: K -> Type) (ctx :: {Unit})
+fun foldRX [K] [tf :: K -> Type] [ctx :: {Unit}]
(f : nm :: Name -> t :: K -> rest :: {K}
-> [[nm] ~ rest] =>
tf t -> xml ctx [] []) =
foldR [tf] [fn _ => xml ctx [] []]
- (fn (nm :: Name) (t :: K) (rest :: {K}) [[nm] ~ rest] r acc =>
+ (fn [nm :: Name] [t :: K] [rest :: {K}] [[nm] ~ rest] r acc =>
<xml>{f [nm] [t] [rest] ! r}{acc}</xml>)
<xml/>
-fun foldRX2 K (tf1 :: K -> Type) (tf2 :: K -> Type) (ctx :: {Unit})
+fun foldRX2 [K] [tf1 :: K -> Type] [tf2 :: K -> Type] [ctx :: {Unit}]
(f : nm :: Name -> t :: K -> rest :: {K}
-> [[nm] ~ rest] =>
tf1 t -> tf2 t -> xml ctx [] []) =
foldR2 [tf1] [tf2] [fn _ => xml ctx [] []]
- (fn (nm :: Name) (t :: K) (rest :: {K}) [[nm] ~ rest]
+ (fn [nm :: Name] [t :: K] [rest :: {K}] [[nm] ~ rest]
r1 r2 acc =>
<xml>{f [nm] [t] [rest] ! r1 r2}{acc}</xml>)
<xml/>
-fun queryI (tables ::: {{Type}}) (exps ::: {Type})
+fun queryI [tables ::: {{Type}}] [exps ::: {Type}]
[tables ~ exps] (q : sql_query tables exps)
(f : $(exps ++ map (fn fields :: {Type} => $fields) tables)
-> transaction unit) =
@@ -169,7 +169,7 @@ fun queryI (tables ::: {{Type}}) (exps ::: {Type})
(fn fs _ => f fs)
()
-fun queryX (tables ::: {{Type}}) (exps ::: {Type}) (ctx ::: {Unit})
+fun queryX [tables ::: {{Type}}] [exps ::: {Type}] [ctx ::: {Unit}]
[tables ~ exps] (q : sql_query tables exps)
(f : $(exps ++ map (fn fields :: {Type} => $fields) tables)
-> xml ctx [] []) =
@@ -177,7 +177,7 @@ fun queryX (tables ::: {{Type}}) (exps ::: {Type}) (ctx ::: {Unit})
(fn fs acc => return <xml>{acc}{f fs}</xml>)
<xml/>
-fun queryX' (tables ::: {{Type}}) (exps ::: {Type}) (ctx ::: {Unit})
+fun queryX' [tables ::: {{Type}}] [exps ::: {Type}] [ctx ::: {Unit}]
[tables ~ exps] (q : sql_query tables exps)
(f : $(exps ++ map (fn fields :: {Type} => $fields) tables)
-> transaction (xml ctx [] [])) =
@@ -187,28 +187,28 @@ fun queryX' (tables ::: {{Type}}) (exps ::: {Type}) (ctx ::: {Unit})
return <xml>{acc}{r}</xml>)
<xml/>
-fun oneOrNoRows (tables ::: {{Type}}) (exps ::: {Type})
+fun oneOrNoRows [tables ::: {{Type}}] [exps ::: {Type}]
[tables ~ exps]
(q : sql_query tables exps) =
query q
(fn fs _ => return (Some fs))
None
-fun oneRow (tables ::: {{Type}}) (exps ::: {Type})
- [tables ~ exps] (q : sql_query tables exps) =
+fun oneRow [tables ::: {{Type}}] [exps ::: {Type}]
+ [tables ~ exps] (q : sql_query tables exps) =
o <- oneOrNoRows q;
return (case o of
None => error <xml>Query returned no rows</xml>
| Some r => r)
-fun eqNullable (tables ::: {{Type}}) (agg ::: {{Type}}) (exps ::: {Type})
- (t ::: Type) (_ : sql_injectable (option t))
+fun eqNullable [tables ::: {{Type}}] [agg ::: {{Type}}] [exps ::: {Type}]
+ [t ::: Type] (_ : sql_injectable (option t))
(e1 : sql_exp tables agg exps (option t))
(e2 : sql_exp tables agg exps (option t)) =
(SQL ({e1} IS NULL AND {e2} IS NULL) OR {e1} = {e2})
-fun eqNullable' (tables ::: {{Type}}) (agg ::: {{Type}}) (exps ::: {Type})
- (t ::: Type) (_ : sql_injectable (option t))
+fun eqNullable' [tables ::: {{Type}}] [agg ::: {{Type}}] [exps ::: {Type}]
+ [t ::: Type] (_ : sql_injectable (option t))
(e1 : sql_exp tables agg exps (option t))
(e2 : option t) =
case e2 of