Added
goal Set.thy "(Union M = {}) = (! A : M. A = {})";
AddIffs [Union_empty_conv];
Good idea??
(* Title: Pure/basis.ML
ID: $Id$
Author: Lawrence C Paulson, Cambridge University Computer Laboratory
Copyright 1993 University of Cambridge
Basis Library emulation.
Needed for Poly/ML and Standard ML of New Jersey version 0.93 to 1.08.
Full compatibility cannot be obtained using a file: what about char constants?
*)
exception Subscript;
structure Bool =
struct
fun toString true = "true"
| toString false = "false"
end;
structure Option =
struct
exception Option
datatype 'a option = NONE | SOME of 'a
fun getOpt (SOME v, _) = v
| getOpt (NONE, a) = a
fun isSome (SOME _) = true
| isSome NONE = false
fun valOf (SOME v) = v
| valOf NONE = raise Option
end;
structure Int =
struct
fun toString (i: int) = makestring i;
fun max (x, y) = if x < y then y else x : int;
fun min (x, y) = if x < y then x else y : int;
end;
structure List =
struct
exception Empty
fun last [] = raise Empty
| last [x] = x
| last (x::xs) = last xs;
fun nth (xs, n) =
let fun h [] _ = raise Subscript
| h (x::xs) n = if n=0 then x else h xs (n-1)
in if n<0 then raise Subscript else h xs n end;
fun drop (xs, n) =
let fun h xs 0 = xs
| h [] n = raise Subscript
| h (x::xs) n = h xs (n-1)
in if n<0 then raise Subscript else h xs n end;
fun take (xs, n) =
let fun h xs 0 = []
| h [] n = raise Subscript
| h (x::xs) n = x :: h xs (n-1)
in if n<0 then raise Subscript else h xs n end;
fun concat [] = []
| concat (l::ls) = l @ concat ls;
fun mapPartial f [] = []
| mapPartial f (x::xs) =
(case f x of Option.NONE => mapPartial f xs
| Option.SOME y => y :: mapPartial f xs);
fun find _ [] = Option.NONE
| find p (x :: xs) = if p x then Option.SOME x else find p xs;
(*copy the list preserving elements that satisfy the predicate*)
fun filter p [] = []
| filter p (x :: xs) = if p x then x :: filter p xs else filter p xs;
(*Partition list into elements that satisfy predicate and those that don't.
Preserves order of elements in both lists.*)
fun partition (p: 'a->bool) (ys: 'a list) : ('a list * 'a list) =
let fun part ([], answer) = answer
| part (x::xs, (ys, ns)) = if p(x)
then part (xs, (x::ys, ns))
else part (xs, (ys, x::ns))
in part (rev ys, ([], [])) end;
end;
structure ListPair =
struct
fun zip ([], []) = []
| zip (x::xs,y::ys) = (x,y) :: zip(xs,ys);
fun unzip [] = ([],[])
| unzip((x,y)::pairs) =
let val (xs,ys) = unzip pairs
in (x::xs, y::ys) end;
fun map f ([], []) = []
| map f (x::xs,y::ys) = f(x,y) :: map f (xs,ys);
fun exists p =
let fun boolf ([], []) = false
| boolf (x::xs,y::ys) = p(x,y) orelse boolf (xs,ys)
in boolf end;
fun all p =
let fun boolf ([], []) = true
| boolf (x::xs,y::ys) = p(x,y) andalso boolf (xs,ys)
in boolf end;
end;
structure TextIO =
struct
type instream = instream
and outstream = outstream
exception Io of {name: string, function: string, cause: exn}
val stdIn = std_in
val stdOut = std_out
val openIn = open_in
val openAppend = open_append
val openOut = open_out
val closeIn = close_in
val closeOut = close_out
val inputN = input
val inputAll = fn is => inputN (is, 999999)
val inputLine = input_line
val endOfStream = end_of_stream
val output = output
val flushOut = flush_out
end;
fun print s = (output (std_out, s); flush_out std_out);