Home My Page Projects Code Snippets Project Openings diderot
Summary Activity Tracker Tasks SCM

SCM Repository

[diderot] Diff of /branches/vis15/src/compiler/basis/basis-vars.sml
ViewVC logotype

Diff of /branches/vis15/src/compiler/basis/basis-vars.sml

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 3391, Tue Nov 10 05:46:48 2015 UTC revision 3511, Fri Dec 18 17:43:38 2015 UTC
# Line 43  Line 43 
43        fun field' (k, d, dd) = field(k, Ty.DimConst d, Ty.Shape(List.map Ty.DimConst dd))        fun field' (k, d, dd) = field(k, Ty.DimConst d, Ty.Shape(List.map Ty.DimConst dd))
44        fun tensor ds = Ty.T_Tensor(Ty.Shape ds)        fun tensor ds = Ty.T_Tensor(Ty.Shape ds)
45        fun matrix d = tensor[d,d]        fun matrix d = tensor[d,d]
46          fun dynSeq ty = Ty.T_Sequence(ty, NONE)
47    
48        fun monoVar (name, ty) = Var.new (name, AST.BasisVar, ty)        fun monoVar (name, ty) = Var.new (name, Error.UNKNOWN, AST.BasisVar, ty)
49        fun polyVar (name, scheme) = Var.newPoly (name, AST.BasisVar, scheme)        fun polyVar arg = Var.newBasis arg
50      in      in
51    
52    (* overloaded operators; the naming convention is to use the operator name followed    (* overloaded operators; the naming convention is to use the operator name followed
# Line 64  Line 65 
65    (* concatenation of sequences *)    (* concatenation of sequences *)
66      val at_dT = polyVar (N.op_at, all([TK],      val at_dT = polyVar (N.op_at, all([TK],
67            fn [Ty.TYPE tv] => let            fn [Ty.TYPE tv] => let
68                val seqTyc = Ty.T_DynSequence(Ty.T_Var tv)                val seqTyc = dynSeq(Ty.T_Var tv)
69                in                in
70                  [seqTyc, Ty.T_Var tv] --> seqTyc                  [seqTyc, Ty.T_Var tv] --> seqTyc
71                end))                end))
72      val at_Td = polyVar (N.op_at, all([TK],      val at_Td = polyVar (N.op_at, all([TK],
73            fn [Ty.TYPE tv] => let            fn [Ty.TYPE tv] => let
74                val seqTyc = Ty.T_DynSequence(Ty.T_Var tv)                val seqTyc = dynSeq(Ty.T_Var tv)
75                in                in
76                  [Ty.T_Var tv, seqTyc] --> seqTyc                  [Ty.T_Var tv, seqTyc] --> seqTyc
77                end))                end))
78      val at_dd = polyVar (N.op_at, all([TK],      val at_dd = polyVar (N.op_at, all([TK],
79            fn [Ty.TYPE tv] => let            fn [Ty.TYPE tv] => let
80                val seqTyc = Ty.T_DynSequence(Ty.T_Var tv)                val seqTyc = dynSeq(Ty.T_Var tv)
81                in                in
82                  [seqTyc, seqTyc] --> seqTyc                  [seqTyc, seqTyc] --> seqTyc
83                end))                end))
# Line 216  Line 217 
217                [f, s] --> f                [f, s] --> f
218              end))              end))
219    
220    (* exponentiation; we distinguish between integer and real exponents to allow x^2 to be compiled    (* power; we distinguish between integer and real exponents to allow x^2 to be compiled
221     * as x*x.     * as x*x.  The power operation of fields is restricted by the typechecker to constant
222       * integer arguments.
223     *)     *)
224      val exp_ri = monoVar(N.op_exp, [Ty.realTy, Ty.T_Int] --> Ty.realTy)      val pow_ri = monoVar(N.op_pow, [Ty.realTy, Ty.T_Int] --> Ty.realTy)
225      val exp_rr = monoVar(N.op_exp, [Ty.realTy, Ty.realTy] --> Ty.realTy)      val pow_rr = monoVar(N.op_pow, [Ty.realTy, Ty.realTy] --> Ty.realTy)
226        val pow_si = polyVar (N.op_pow, all([DK, NK], fn [Ty.DIFF k, Ty.DIM d] => let
227              val k = Ty.DiffVar(k, 0)
228              val d = Ty.DimVar d
229              val fld = field(k, d, Ty.Shape[])
230              in
231                [fld, Ty.T_Int] --> fld
232              end))
233    
234      val convolve_vk = polyVar (N.op_convolve, all([DK, NK, SK], fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let      val convolve_vk = polyVar (N.op_convolve, all([DK, NK, SK], fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
235              val k = Ty.DiffVar(k, 0)              val k = Ty.DiffVar(k, 0)
# Line 273  Line 282 
282      val neq_rr = monoVar(N.op_neq, [Ty.realTy, Ty.realTy] --> Ty.T_Bool)      val neq_rr = monoVar(N.op_neq, [Ty.realTy, Ty.realTy] --> Ty.T_Bool)
283    
284      val neg_i = monoVar(N.op_neg, [Ty.T_Int] --> Ty.T_Int)      val neg_i = monoVar(N.op_neg, [Ty.T_Int] --> Ty.T_Int)
285      val neg_t = polyVar(N.op_neg, all([SK],      val neg_t = polyVar(N.op_neg, all([SK], fn [Ty.SHAPE dd] => let
           fn [Ty.SHAPE dd] => let  
286                val t = Ty.T_Tensor(Ty.ShapeVar dd)                val t = Ty.T_Tensor(Ty.ShapeVar dd)
287                in                in
288                  [t] --> t                  [t] --> t
289                end))                end))
290      val neg_f = polyVar(N.op_neg, all([DK, NK, SK],      val neg_f = polyVar(N.op_neg, all([DK, NK, SK], fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let
           fn [Ty.DIFF k, Ty.DIM d, Ty.SHAPE dd] => let  
291                val k = Ty.DiffVar(k, 0)                val k = Ty.DiffVar(k, 0)
292                val d = Ty.DimVar d                val d = Ty.DimVar d
293                val dd = Ty.ShapeVar dd                val dd = Ty.ShapeVar dd
# Line 296  Line 303 
303              [t, t, t] --> t              [t, t, t] --> t
304            end))            end))
305    
306      val lerp3 = polyVar(N.fn_lerp, all([SK],      val lerp3 = polyVar(N.fn_lerp, all([SK], fn [Ty.SHAPE dd] => let
           fn [Ty.SHAPE dd] => let  
307                val t = Ty.T_Tensor(Ty.ShapeVar dd)                val t = Ty.T_Tensor(Ty.ShapeVar dd)
308                in                in
309                  [t, t, Ty.realTy] --> t                  [t, t, Ty.realTy] --> t
310                end))                end))
311      val lerp5 = polyVar(N.fn_lerp, all([SK],      val lerp5 = polyVar(N.fn_lerp, all([SK], fn [Ty.SHAPE dd] => let
           fn [Ty.SHAPE dd] => let  
312                val t = Ty.T_Tensor(Ty.ShapeVar dd)                val t = Ty.T_Tensor(Ty.ShapeVar dd)
313                in                in
314                  [t, t, Ty.realTy, Ty.realTy, Ty.realTy] --> t                  [t, t, Ty.realTy, Ty.realTy, Ty.realTy] --> t
# Line 313  Line 318 
318     * we overload the function.     * we overload the function.
319     *)     *)
320      local      local
321        fun evals d = monoVar (N.fn_evals, [matrix d] --> Ty.T_Sequence(Ty.realTy, d))        fun evals d = monoVar (N.fn_evals, [matrix d] --> Ty.T_Sequence(Ty.realTy, SOME d))
322        fun evecs d = monoVar (N.fn_evecs, [matrix d] --> Ty.T_Sequence(tensor[d], d))        fun evecs d = monoVar (N.fn_evecs, [matrix d] --> Ty.T_Sequence(tensor[d], SOME d))
323      in      in
324      val evals2x2 = evals(Ty.DimConst 2)      val evals2x2 = evals(Ty.DimConst 2)
325      val evecs2x2 = evecs(Ty.DimConst 2)      val evecs2x2 = evecs(Ty.DimConst 2)
326      val evals3x3 = evals(Ty.DimConst 3)      val evals3x3 = evals(Ty.DimConst 3)
327      val evecs3x3 = evecs(Ty.DimConst 3)      val evecs3x3 = evecs(Ty.DimConst 3)
328      end      end (* local *)
329    
330    (***** non-overloaded operators, etc. *****)    (***** non-overloaded operators, etc. *****)
331    
   (* C math functions *)  
     val mathFns : (MathFuns.name * Var.var) list = let  
           fun ty n = List.tabulate(MathFuns.arity n, fn _ => Ty.realTy) --> Ty.realTy  
           in  
             List.map (fn n => (n, monoVar(MathFuns.toAtom n, ty n))) MathFuns.allFuns  
           end  
   
332    (* integer modulo *)    (* integer modulo *)
333      val op_mod = monoVar(N.op_mod, [Ty.T_Int, Ty.T_Int] --> Ty.T_Int)      val op_mod = monoVar(N.op_mod, [Ty.T_Int, Ty.T_Int] --> Ty.T_Int)
334    
# Line 390  Line 388 
388                [f1] --> f2                [f1] --> f2
389              end))              end))
390    
391      (* boolean operators; 'and' and 'or' are used to implement reductions *)
392        val op_and = monoVar (Atom.atom "$and", [Ty.T_Bool, Ty.T_Bool] --> Ty.T_Bool)
393        val op_or = monoVar (Atom.atom "$or", [Ty.T_Bool, Ty.T_Bool] --> Ty.T_Bool)
394      val op_not = monoVar (N.op_not, [Ty.T_Bool] --> Ty.T_Bool)      val op_not = monoVar (N.op_not, [Ty.T_Bool] --> Ty.T_Bool)
395    
396    (* cross product *)    (* cross product *)
# Line 407  Line 408 
408      in      in
409      val op_cross2_tt = monoVar (N.op_cross, crossTy2)      val op_cross2_tt = monoVar (N.op_cross, crossTy2)
410      val op_cross3_tt = monoVar (N.op_cross, crossTy)      val op_cross3_tt = monoVar (N.op_cross, crossTy)
411      end      end (* local *)
412    
413      val op_cross2_ff  = polyVar (N.op_cross, all([DK], fn [Ty.DIFF k] => let      val op_cross2_ff  = polyVar (N.op_cross, all([DK], fn [Ty.DIFF k] => let
414              fun field' (k, d, dd) = field(k, Ty.DimConst d, Ty.Shape(List.map Ty.DimConst dd))              fun field' (k, d, dd) = field(k, Ty.DimConst d, Ty.Shape(List.map Ty.DimConst dd))
# Line 515  Line 516 
516                  val d = Ty.DimVar d                  val d = Ty.DimVar d
517                  val dd = Ty.ShapeVar dd                  val dd = Ty.ShapeVar dd
518                  in                  in
519                    [Ty.T_Image{dim=d, shape=dd}] --> Ty.T_Sequence(Ty.T_Int, d)                    [Ty.T_Image{dim=d, shape=dd}] --> Ty.T_Sequence(Ty.T_Int, SOME d)
520                  end))                  end))
521    
522    (* functions that handle the boundary behavior of an image *)    (* functions that handle the boundary behavior of an image *)
# Line 562  Line 563 
563    
564    (* load dynamic sequence from nrrd *)    (* load dynamic sequence from nrrd *)
565      val fn_load = polyVar (N.fn_load, all([TK],      val fn_load = polyVar (N.fn_load, all([TK],
566              fn [Ty.TYPE tv] => [Ty.T_String] --> Ty.T_DynSequence(Ty.T_Var tv)))              fn [Ty.TYPE tv] => [Ty.T_String] --> dynSeq(Ty.T_Var tv)))
567    
568      val fn_length = polyVar (N.fn_length, all([TK],      val fn_length = polyVar (N.fn_length, all([TK],
569              fn [Ty.TYPE tv] => [Ty.T_DynSequence(Ty.T_Var tv)] --> Ty.T_Int))              fn [Ty.TYPE tv] => [dynSeq(Ty.T_Var tv)] --> Ty.T_Int))
570    
571      val fn_max = monoVar (N.fn_max, [Ty.realTy, Ty.realTy] --> Ty.realTy)      val fn_abs_i = monoVar (N.fn_abs, [Ty.T_Int] --> Ty.T_Int)
572      val fn_min = monoVar (N.fn_min, [Ty.realTy, Ty.realTy] --> Ty.realTy)      val fn_abs_r = monoVar (N.fn_abs, [Ty.realTy] --> Ty.realTy)
573        val fn_max_i = monoVar (N.fn_max, [Ty.T_Int, Ty.T_Int] --> Ty.T_Int)
574        val fn_max_r = monoVar (N.fn_max, [Ty.realTy, Ty.realTy] --> Ty.realTy)
575        val fn_min_i = monoVar (N.fn_min, [Ty.T_Int, Ty.T_Int] --> Ty.T_Int)
576        val fn_min_r = monoVar (N.fn_min, [Ty.realTy, Ty.realTy] --> Ty.realTy)
577    
578      val fn_modulate = polyVar (N.fn_modulate, all([NK],      val fn_modulate = polyVar (N.fn_modulate, all([NK],
579            fn [Ty.DIM d] => let            fn [Ty.DIM d] => let
# Line 577  Line 582 
582                [t, t] --> t                [t, t] --> t
583              end))              end))
584    
585      val fn_normalize_t = polyVar (N.fn_normalize, all([NK],      val fn_normalize_t = polyVar (N.fn_normalize, all([SK],
586            fn [Ty.DIM d] => let            fn [Ty.SHAPE dd] => let
587              val t = Ty.T_Tensor(Ty.Shape[Ty.DimVar d])              val t = Ty.T_Tensor(Ty.ShapeVar dd)
588              in              in
589                [t] --> t                [t] --> t
590              end))              end))
# Line 603  Line 608 
608              end              end
609      in      in
610      val op_outer_tt = polyVar (N.op_outer, all([NK, NK], mkOuter))      val op_outer_tt = polyVar (N.op_outer, all([NK, NK], mkOuter))
611        end (* local *)
612    
613        local
614          fun mkOuter2 [Ty.DIM d1, Ty.DIM d2, Ty.DIM d3] = let
615                val vt1 = Ty.T_Tensor(Ty.Shape[Ty.DimVar d1])
616                val vt2 = Ty.T_Tensor(Ty.Shape[Ty.DimVar d2, Ty.DimVar d3])
617                val mt = Ty.T_Tensor(Ty.Shape[Ty.DimVar d1, Ty.DimVar d2, Ty.DimVar d3])
618                in
619                  [vt1, vt2] --> mt
620      end      end
621        in
622          val op_outer_tm = polyVar (N.op_outer, all([NK, NK, NK], mkOuter2))
623        end (* local *)
624    
625        local
626          fun mkOuter3 [Ty.DIM d1, Ty.DIM d2, Ty.DIM d3] = let
627                val vt1 = Ty.T_Tensor(Ty.Shape[Ty.DimVar d1,Ty.DimVar d2])
628                val vt2 = Ty.T_Tensor(Ty.Shape[Ty.DimVar d3])
629                val mt = Ty.T_Tensor(Ty.Shape[Ty.DimVar d1, Ty.DimVar d2,Ty.DimVar d3])
630                in
631                  [vt1, vt2] --> mt
632                end
633        in
634          val op_outer_mt = polyVar (N.op_outer, all([NK, NK,NK], mkOuter3))
635        end (* local *)
636    
637      local      local
638        fun mkOuterField [Ty.DIFF k, Ty.DIM d,Ty.DIM a, Ty.DIM b] = let        fun mkOuterField [Ty.DIFF k, Ty.DIM d,Ty.DIM a, Ty.DIM b] = let
# Line 619  Line 648 
648              end              end
649      in      in
650      val op_outer_ff = polyVar (N.op_outer, all([DK,NK,NK,NK], mkOuterField))      val op_outer_ff = polyVar (N.op_outer, all([DK,NK,NK,NK], mkOuterField))
651      end      end (* local *)
652    
653      val fn_principleEvec = polyVar (N.fn_principleEvec, all([NK],      val fn_principleEvec = polyVar (N.fn_principleEvec, all([NK],
654              fn [Ty.DIM d] => let              fn [Ty.DIM d] => let
# Line 676  Line 705 
705                [f] --> s                [f] --> s
706              end))              end))
707    
708    (* sqrt *)    (* lifted unary math functions; these have both real and scalar-field forms *)
709      val fn_sqrt_t = monoVar (N.fn_sqrt, [Ty.realTy] --> Ty.realTy)      local
710      val fn_sqrt_f = polyVar (N.fn_sqrt, all([DK,NK], fn [Ty.DIFF k, Ty.DIM d] => let        fun fn_r name = monoVar (name, [Ty.realTy] --> Ty.realTy)
711          fun fn_s name = polyVar (N.fn_sqrt, all([DK,NK], fn [Ty.DIFF k, Ty.DIM d] => let
712            val k' = Ty.DiffVar(k, 0)            val k' = Ty.DiffVar(k, 0)
713            val d' = Ty.DimVar d            val d' = Ty.DimVar d
714            val f = field(k', d', Ty.Shape[])            val f = field(k', d', Ty.Shape[])
715            in            in
716              [f] --> f              [f] --> f
717            end))            end))
718        in
719        val fn_sqrt_r = fn_r N.fn_sqrt
720        val fn_sqrt_s = fn_s N.fn_sqrt
721        val fn_cos_r  = fn_r N.fn_cos
722        val fn_cos_s  = fn_s N.fn_cos
723        val fn_acos_r = fn_r N.fn_acos
724        val fn_acos_s = fn_s N.fn_acos
725        val fn_sin_r  = fn_r N.fn_sin
726        val fn_sin_s  = fn_s N.fn_sin
727        val fn_asin_r = fn_r N.fn_asin
728        val fn_asin_s = fn_s N.fn_asin
729        val fn_tan_r  = fn_r N.fn_tan
730        val fn_tan_s  = fn_s N.fn_tan
731        val fn_atan_r = fn_r N.fn_atan
732        val fn_atan_s = fn_s N.fn_atan
733        val fn_exp_r  = fn_r N.fn_exp
734        val fn_exp_s  = fn_s N.fn_exp
735        end (* local *)
736    
737    (* cosine *)    (* Math functions that have not yet been lifted to work on fields *)
738      val fn_cos_t = monoVar (N.fn_cos, [Ty.realTy] --> Ty.realTy)      local
739      val fn_cos_f = polyVar (N.fn_cos, all([DK,NK], fn [Ty.DIFF k, Ty.DIM d] => let        fun mk (name, n) =
740              val k' = Ty.DiffVar(k, 0)              monoVar(name, List.tabulate(n, fn _ => Ty.realTy) --> Ty.realTy)
             val d' = Ty.DimVar d  
             val f = field(k', d', Ty.Shape[])  
741              in              in
742                [f] --> f      val fn_atan2_rr = mk(N.fn_atan2, 2)
743              end))      val fn_ceil_r   = mk(N.fn_ceil, 1)
744        val fn_floor_r  = mk(N.fn_floor, 1)
745        val fn_fmod_rr  = mk(N.fn_fmod, 2)
746        val fn_erf_r    = mk(N.fn_erf, 1)
747        val fn_erfc_r   = mk(N.fn_erfc, 1)
748        val fn_log_r    = mk(N.fn_log, 1)
749        val fn_log10_r  = mk(N.fn_log10, 1)
750        val fn_log2_r   = mk(N.fn_log2, 1)
751        val fn_pow_rr   = mk(N.fn_pow, 2)
752        end (* local *)
753    
754    (* arc cosine *)    (* Query functions *)
755      val fn_acos_t = monoVar (N.fn_acos, [Ty.realTy] --> Ty.realTy)      local
756      val fn_acos_f = polyVar (N.fn_acos, all([DK,NK], fn [Ty.DIFF k, Ty.DIM d] => let        val implicit = fn [Ty.TYPE tv] => [Ty.realTy] --> dynSeq(Ty.T_Var tv)
757              val k' = Ty.DiffVar(k, 0)        val realTy = fn [Ty.TYPE tv] => [Ty.realTy, Ty.realTy] --> dynSeq(Ty.T_Var tv)
758              val d' = Ty.DimVar d        val vec2Ty = let
759              val f = field(k', d', Ty.Shape[])              val t = tensor[N2]
760              in              in
761                [f] --> f                fn [Ty.TYPE tv] => [t, Ty.realTy] --> dynSeq(Ty.T_Var tv)
762              end))              end
763          val vec3Ty = let
764                val t = tensor[N3]
765                in
766                  fn [Ty.TYPE tv] => [t, Ty.realTy] --> dynSeq(Ty.T_Var tv)
767                end
768        in
769        val fn_sphere_im = polyVar (N.fn_sphere, all([TK], implicit))
770        val fn_sphere1_r = polyVar (N.fn_sphere, all([TK], realTy))
771        val fn_sphere2_t = polyVar (N.fn_sphere, all([TK], vec2Ty))
772        val fn_sphere3_t = polyVar (N.fn_sphere, all([TK], vec3Ty))
773        end (* local *)
774    
775    (* sine *)    (* vector distance function *)
776      val fn_sin_t = monoVar (N.fn_sin, [Ty.realTy] --> Ty.realTy)      local
777      val fn_sin_f = polyVar (N.fn_sin, all([DK,NK], fn [Ty.DIFF k, Ty.DIM d] => let        val vec2Ty = let
778              val k' = Ty.DiffVar(k, 0)              val t = tensor[N2]
             val d' = Ty.DimVar d  
             val f = field(k', d', Ty.Shape[])  
779              in              in
780                [f] --> f                [t, t] --> Ty.realTy
781              end))              end
782          val vec3Ty = let
783                val t = tensor[N3]
784                in
785                  [t, t] --> Ty.realTy
786                end
787        in
788        val dist2_t  = monoVar (N.fn_dist, vec2Ty)
789        val dist3_t  = monoVar (N.fn_dist, vec3Ty)
790        end (* local *)
791    
792    (* arc sine *)    (* Sets of strands *)
793      val fn_asin_t = monoVar (N.fn_asin, [Ty.realTy] --> Ty.realTy)      local
794      val fn_asin_f = polyVar (N.fn_asin, all([DK,NK], fn [Ty.DIFF k, Ty.DIM d] => let        fun mkSetFn name = polyVar (name, all([TK], fn [Ty.TYPE tv] => [] --> dynSeq(Ty.T_Var tv)))
             val k' = Ty.DiffVar(k, 0)  
             val d' = Ty.DimVar d  
             val f = field(k', d', Ty.Shape[])  
795              in              in
796                [f] --> f      val set_active = mkSetFn N.set_active
797              end))      val set_all    = mkSetFn N.set_all
798        val set_stable = mkSetFn N.set_stable
799        end
800    
801      (* reduction operators *)
802        local
803          fun reduction (name, elemTy) =
804                monoVar (name, [dynSeq elemTy] --> elemTy)
805        in
806        val red_all         = reduction (N.fn_all, Ty.T_Bool)
807        val red_exists      = reduction (N.fn_exists, Ty.T_Bool)
808    (* FIXME: allow max on integers *)
809        val red_max         = reduction (N.fn_max, Ty.realTy)
810        val red_mean        = reduction (N.fn_mean, Ty.realTy)
811    (* FIXME: allow min on integers *)
812        val red_min         = reduction (N.fn_min, Ty.realTy)
813        val red_product     = reduction (N.fn_product, Ty.realTy)
814    (* FIXME: allow sum on int and tensor types *)
815        val red_sum         = reduction (N.fn_sum, Ty.realTy)
816        val red_variance    = reduction (N.fn_variance, Ty.realTy)
817        end (* local *)
818    
819    (* kernels *)    (* kernels *)
820  (* FIXME: we should really get the continuity info from the kernels themselves *)  (* FIXME: we should really get the continuity info from the kernels themselves *)
# Line 753  Line 843 
843    (* sequence subscript *)    (* sequence subscript *)
844      val subscript = polyVar (Atom.atom "$sub", all ([TK, NK],      val subscript = polyVar (Atom.atom "$sub", all ([TK, NK],
845            fn [Ty.TYPE tv, Ty.DIM d] =>            fn [Ty.TYPE tv, Ty.DIM d] =>
846              [Ty.T_Sequence(Ty.T_Var tv, Ty.DimVar d), Ty.T_Int] --> Ty.T_Var tv))              [Ty.T_Sequence(Ty.T_Var tv, SOME(Ty.DimVar d)), Ty.T_Int] --> Ty.T_Var tv))
847    
848      val dynSubscript = polyVar (Atom.atom "$dynsub", all ([TK],      val dynSubscript = polyVar (Atom.atom "$dynsub", all ([TK],
849            fn [Ty.TYPE tv] => [Ty.T_DynSequence(Ty.T_Var tv), Ty.T_Int] --> Ty.T_Var tv))            fn [Ty.TYPE tv] => [dynSeq(Ty.T_Var tv), Ty.T_Int] --> Ty.T_Var tv))
850    
851   (* range expressions *)   (* range expressions *)
852      val range = monoVar (Atom.atom "$range", [Ty.T_Int, Ty.T_Int] --> Ty.T_DynSequence Ty.T_Int)      val range = monoVar (Atom.atom "$range", [Ty.T_Int, Ty.T_Int] --> dynSeq Ty.T_Int)
853    
854      end (* local *)      end (* local *)
855    end    end

Legend:
Removed from v.3391  
changed lines
  Added in v.3511

root@smlnj-gforge.cs.uchicago.edu
ViewVC Help
Powered by ViewVC 1.0.0