Return to standard.sml CVS log

Up to [Research Unix] / researchv10no / cmd / sml / lib

Annotation of researchv10no/cmd/sml/lib/standard.sml, revision 1.1

1.1     ! root        1: (* Standard environment, as defined in Definition of SML, Version 2 *)
        !             2: 
        !             3: structure Standard = 
        !             4:   struct
        !             5: 
        !             6:     infix 7 * / div mod
        !             7:     infix 6 + - ^
        !             8:     infixr 5 :: @
        !             9:     infix 4 = <> < > <= >=
        !            10:     infix 3 o :=
        !            11: 
        !            12:     val ! = Ref.!
        !            13:     val op := = Ref.:=
        !            14:     val not = Bool.not
        !            15:     val floor = Real.floor
        !            16:     val truncate = Real.truncate
        !            17:     val ceiling = Real.ceiling
        !            18:     val real = Real.real
        !            19:     val sin = Real.sin and cos = Real.cos 
        !            20:     and sqrt = Real.sqrt and arctan = Real.arctan
        !            21:     and exp = Real.exp and ln = Real.ln
        !            22:     and rev = List.rev and map = List.map and op @ = List.@
        !            23:     exception Floor=Real.Floor and Sqrt=Real.Sqrt
        !            24:     exception Exp=Real.Exp and Ln=Real.Ln
        !            25:     val op / = Real./
        !            26:     
        !            27:     exception Mod
        !            28:     exception Quot
        !            29:     exception Prod
        !            30:     exception Sum
        !            31:     exception Diff
        !            32:     exception Chr = String.Chr and Ord = String.Ord
        !            33:     exception Div = Integer.Div
        !            34: 
        !            35:     val op + = fn (a,b) => Integer.+(a,b) handle Integer.Overflow => raise Sum
        !            36:     val op * = fn (a,b) => Integer.*(a,b) handle Integer.Overflow => raise Prod
        !            37:     val op div = fn (a,b) =>
        !            38:        (if Integer.>=(a,0)
        !            39:        then if Integer.>=(b,0)
        !            40:             then Integer.div(a,b)
        !            41:             else Integer.-(Integer.div(Integer.-(a,1),b),1)
        !            42:        else if Integer.>=(b,0)
        !            43:             then Integer.-(Integer.div(Integer.+(a,1),b),1)
        !            44:             else Integer.div(a,b)) handle Integer.Overflow => raise Div
        !            45:     val op - = fn (a,b) => Integer.-(a,b) handle Integer.Overflow => raise Diff
        !            46:     val op mod = fn (a,b) => Integer.-(a,Integer.*(a div b,b))
        !            47:                             handle Div => raise Mod
        !            48:                                  | Integer.Overflow => raise Mod
        !            49:     structure BasicIO : BASICIO = IO
        !            50:     open BasicIO
        !            51:     val output = fn (f,s) => output f s
        !            52:     val input = fn (f,i) => input f i
        !            53:     val size = String.size
        !            54:     val explode = String.explode and implode = String.implode
        !            55:     val op ^ = String.^
        !            56:     val chr = String.chr and ord = String.ord
        !            57:         
        !            58:     val op o = General.o and op = = General.= and op <> = General.<>
        !            59:     exception Bind= General.Bind and Match = General.Match
        !            60:     exception Interrupt = General.Interrupt
        !            61:   end (* structure Standard *)
        !            62: 
        !            63: structure Standard =
        !            64:   struct
        !            65:     open Standard
        !            66:     overload ~ : ('a->'a) as Integer.~ and Real.~
        !            67:     overload + : ('a*'a -> 'a) as Standard.+ and Real.+
        !            68:     overload - : ('a*'a -> 'a) as Standard.- and Real.-
        !            69:     overload * : ('a*'a -> 'a) as Standard.* and Real.*
        !            70:     overload < : ('a*'a -> bool) as Integer.< and Real.<
        !            71:     overload > : ('a*'a -> bool) as Integer.> and Real.>
        !            72:     overload <= : ('a*'a -> bool) as Integer.<= and Real.<=
        !            73:     overload >= : ('a*'a -> bool) as Integer.>= and Real.>=
        !            74:     overload abs : ('a->'a) as Integer.abs and Real.abs
        !            75: 
        !            76:   end (* structure Environ *)

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.