]> gerrit.simantics Code Review - simantics/platform.git/blob - bundles/org.simantics.scl.runtime/scl/Prelude.scl
New parametrisation of OpenDiagramFromConfigurationAdapter.openEditor
[simantics/platform.git] / bundles / org.simantics.scl.runtime / scl / Prelude.scl
1 import "JavaBuiltin" as Java
2 import "StringBuilder" as StringBuilder
3
4 /** The following types and names are builtin *************
5 data Boolean = True | False
6 data Byte
7 data Character
8 data Short
9 data Integer
10 data Long
11 data Float
12 data Double
13 data BooleanArray
14 data ByteArray
15 data CharacterArray
16 data ShortArray
17 data IntegerArray
18 data LongArray
19 data FloatArray
20 data DoubleArray
21 data Array a
22 data String
23 data a -> b
24 data [a] = [] | [a] | [a,a] | [a,a,a] | ...
25 data () = ()
26 data (a,b) = (a,b)
27 data (a,b,c) = (a,b,c)
28 data Maybe a = Nothing | Just a
29
30 fail :: String -> a
31
32 data TypeRep = TCon String | TApply TypeRep TypeRep
33 class Typeable a
34 typeOf :: Typeable a => a -> Type
35
36 data Binding a
37 class Serializable a
38 binding :: Serializable a => Binding a
39 ***********************************************************/
40
41 type BooleanArray = Vector Boolean
42 type ByteArray = Vector Byte
43 type CharacterArray = Vector Character
44 type ShortArray = Vector Short
45 type IntegerArray = Vector Integer
46 type LongArray = Vector Long
47 type FloatArray = Vector Float
48 type DoubleArray = Vector Double
49
50 importJava "java.util.Arrays" where
51     "Converts an array to a list."
52     @JavaName asList    
53     arrayToList :: Array a -> [a]
54
55 importJava "java.util.List" where
56     "Converts a list to an array."
57     @JavaName toArray
58     listToArray :: [a] -> Array a
59
60 importJava "org.simantics.scl.runtime.Coercion" where
61     "Converts a list of doubles to a double array."
62     toDoubleArray :: [Double] -> DoubleArray
63     "Converts a double array to a list of doubles."
64     fromDoubleArray :: DoubleArray -> [Double]
65
66 /*
67  * Precedences and associativity of all operators defined in Prelude
68  */
69
70 infixr 10 (!)
71 infixr 9  (.)
72 infixr 8  (^)
73 infixl 7  (*), (/), div, mod
74 infixl 6  (+), (-)
75 infixl 5  (\\), (<<), (<+)
76 infix  4  (!=), (<), (<=), (>=), (>)
77 infixr 3  (&&), (&<&)
78 infixr 2  (||), orElse, morelse
79 infixr 1  (>>=), (>>), (:=), (>=>)
80 infixr 1  ($)
81 infixl 1  catch
82
83 "Creates a constant function. `const x` defines a function that always returns `x`."
84 @inline
85 const :: a -> b -> a
86 const c x = c
87
88 """
89 Function application. `f $ x` is equivalent with `f x`. The function has two uses.
90 First is to remove parentheses from deeply nested expressions:
91
92     f (g (h x))  ==  f $ g $ h x
93     
94 The second use is with higher order functions:
95
96     map ($ parameter) functions
97 """
98 @macro
99 @inline
100 ($) :: (a -> <e> b) -> a -> <e> b
101 f $ x = f x
102
103 "Transforms a function taking a pair as a parameter to a function taking two values as a parameter."
104 @inline
105 curry :: ((a, b) -> <e> c) -> a -> b -> <e> c
106 curry f x y =  f (x, y)
107
108 "Transforms a function two values as a parameter to a function taking a pair as a parameter."
109 @inline
110 uncurry :: (a -> b -> <e> c) -> ((a, b) -> <e> c)
111 uncurry f (x, y) = f x y
112
113 "Transforms a function taking a triple as a parameter to a function taking three values as a parameter."
114 @inline
115 curry3 :: ((a, b, c) -> <e> d) -> a -> b -> c -> <e> d
116 curry3 f x y z =  f (x, y, z)
117
118 "Transforms a function three values as a parameter to a function taking a priple as a parameter."
119 @inline
120 uncurry3 :: (a -> b -> c -> <e> d) -> ((a, b, c) -> <e> d)
121 uncurry3 f (x, y, z) = f x y z
122
123 "Flips the parameters of a binary function."
124 @inline
125 flip :: (a -> b -> <e> c) -> b -> a -> <e> c
126 flip f x y =  f y x
127
128 "Swaps the order of elements of a pair (2-tuple)."
129 swap :: (a,b) -> (b,a)
130 swap (x,y) = (y,x)
131
132 /// Comparison ///
133
134 @inline
135 (!=) :: a -> a -> Boolean
136 a != b = not (a == b)
137
138 """
139 The class of linearly ordered types.
140 Method `compare` must be implemented in instances. 
141 """
142 class Ord a where
143     """
144     `compare x y` returns a negative number, if `x` is smaller than `y`,
145     a positive number, if `x` is bigger than `y` and zero if they are equal. 
146     """
147     compare :: a -> a -> Integer
148     compare a b = if a < b then -1 else if a > b then 1 else 0
149     
150     "Less"
151     (<) :: a -> a -> Boolean
152     a < b = compare a b < 0
153     "Less or equal"
154     (<=) :: a -> a -> Boolean
155     a <= b = compare a b <= 0
156     "Greater"
157     (>) :: a -> a -> Boolean
158     a > b = compare a b > 0
159     "Greater or equal"
160     (>=) :: a -> a -> Boolean
161     a >= b = compare a b >= 0
162     
163     "Minimum of the parameters"
164     min :: a -> a -> a
165     min a b = if a < b then a else b
166     "Maximum of the parameters"
167     max :: a -> a -> a
168     max a b = if a > b then a else b
169
170 """
171 Combines two integers such that if the first one is non-zero, it is returned, otherwise
172 the second-one. The second parameter is not implemented, if it is not needed.
173
174 The function is useful for implementing efficient recursive comparison of structures,
175 for example:
176
177     compare (x1,y1,z1) (x2,y2,z2) = compare x1 x2 &<& compare y1 y2 &<& compare z1 z2
178 """
179 @inline
180 (&<&) :: Integer -> (<e> Integer) -> <e> Integer
181 a &<& b = if a == 0 then b else a
182
183 "Maximum over a list"
184 @inline
185 maximum :: Ord a => [a] -> a
186 maximum = foldl1 max
187
188 "Minimum over a list"
189 @inline
190 minimum :: Ord a => [a] -> a
191 minimum = foldl1 min
192
193 "As `maximum` but compares the elements by the given projection."
194 maximumBy :: Ord b => (a -> <e> b) -> [a] -> <e> a
195 maximumBy f l = snd $ foldl1 maxF $ map (\x -> (f x, x)) l
196   where
197     maxF a b = if fst a >= fst b then a else b
198
199 """
200 As `minimum` but compares the elements by the given projection.
201 For example
202
203     minimumBy snd l
204     
205 returns a pair with the smallest second component.
206 """    
207 minimumBy :: Ord b => (a -> <e> b) -> [a] -> <e> a
208 minimumBy f l = snd $ foldl1 minF $ map (\x -> (f x, x)) l
209   where
210     minF a b = if fst a <= fst b then a else b  
211
212 /// Functions ///
213 /*
214 instance Functor ((->) a) where
215     map f g x = f (g x)
216
217 instance Monad ((->) a) where
218     return v x = v
219     (m >>= f) x = f (m x) x
220     join f x = f x x
221
222 instance Category (->) where
223     id x = x
224     @inline
225     (f . g) x = f (g x)
226 */
227 instance (Additive b) => Additive (a -> <e> b) where
228     zero x = zero
229     (f + g) x = f x + g x
230
231 instance (Ring b) => Ring (a -> <e> b) where
232     one x = one
233     (neg f) x = neg (f x)
234     (f - g) x = f x - g x
235     (f * g) x = f x * g x
236     (fromInteger c) x = fromInteger c
237
238 //instance Show (a -> <e> b) where
239 //    show f = "<function>"
240
241 "Appends a string to the string builder."
242 (<<) :: StringBuilder.T -> String -> <Proc> StringBuilder.T
243 (<<) =  StringBuilder.appendString
244
245 """
246 The class of types whose elements can be converted to a string representation.
247 Method `show` or `(<+)` must be implemented.
248 """
249 class Show a where
250     "Converts a value to string."
251     show :: a -> String
252     "Appends the string representation of the value to the string builder."
253     (<+) :: StringBuilder.T -> a -> <Proc> StringBuilder.T
254     """
255     Returns the precedence of the value. It is used to determine if parenteheses
256     are needed around the string representation of the value. The default value is 0
257     and means that parentheses are never added.
258     """ 
259     precedence :: a -> Integer
260     
261     "Converts a value to a string like `show` but does not put string literals in double quotes."
262     showForPrinting :: a -> String
263     
264     show v = runProc (StringBuilder.toString (StringBuilder.new <+ v))
265     showForPrinting v = show v
266     sb <+ v = StringBuilder.appendString sb (show v)
267     precedence v = 0
268
269 """
270 `Par` data type is used to control the placement of parentheses when converting values to string.
271 Value `Par prec val` is converted to string like `val` but parentheses are put around, if the 
272 precedence of the value is greater than `prec`.
273 """
274 data Par a = Par Integer a
275
276 instance (Show a) => Show (Par a) where
277     sb <+ (Par outerPrec v) = if prec > outerPrec
278                                  then sb << "(" <+ v << ")"
279                                  else sb <+ v
280                               where prec = precedence v
281
282 "Type class for parsing strings to values."
283 class Read a where
284     "Converts a string to a required type of value."
285     read :: String -> a
286 """
287 The `Additive` class is used for types that are additive monoids. The operations
288 must satisfy the following laws (at least approximately, when implemented for
289 floating point numbers):
290     (a + b) + c   = a + (b + c)
291     a + 0 = 0 + a = a
292 """
293 class Additive a where
294     """
295     Neutral element of (+), i.e,
296     
297         x + zero == x
298         zero + x == x       
299     """
300     zero :: a
301     "Adds two objects (numbers, vectors, strings, etc.) together."
302     (+)  :: a -> a -> a
303     """
304     Sum of the elements:
305     
306         sum [e1,e2,...,eN] = e1 + e2 + ... + eN
307     
308     Implemented usually more efficiently than with repetitive 
309     application of `(+)`.
310     """
311     sum  :: [a] -> a
312     sum = foldl (+) zero    
313 /*
314 class (Additive a) => AdditiveGroup a where
315     neg :: a -> a    
316     (-) :: a -> a -> a
317     x - y = x + (neg y)
318 */
319 """
320 The `Ring` class is used for types that are algebraic rings. The operations
321 must satisfy the following laws (at least approximately)
322 in addition to the laws of Additive:
323
324     a + b         = b + a
325     a - b         = a + (neg b)
326     a - a         = 0
327     (a * b) * c   = a * (b * c)
328     a * 1 = 1 * a = a
329     a * (b + c)   = a * b + a * c
330     (a + b) * c   = a * c + b * c 
331 """
332 class (Additive a) => Ring a where
333     """
334     Negation. Synonym for unary `-`.
335     """
336     neg :: a -> a
337     "Subtraction"    
338     (-) :: a -> a -> a
339     "Neutral element of multiplication"
340     one :: a
341     "Multiplication"
342     (*) :: a -> a -> a
343     "Converts an integer to a desired numeric type."
344     fromInteger :: Integer -> a
345     x - y = x + (neg y)
346     
347
348 """
349 The `OrderedRing` class combines the Ring and Ord classes. It additionally 
350 supports absolute value function.
351 """    
352 class (Ring a, Ord a) => OrderedRing a where
353     "Absolute value."
354     abs :: a -> a
355     abs x = if x < zero then neg x else x
356     "Converts the given number to `Integer`"
357     toInteger :: a -> Integer   
358
359 """
360 The `Integer` class is used for types that represent either all integers or some
361 range of them. 
362 """
363 class (OrderedRing a) => Integral a where
364     "Integer division truncated toward zero."
365     div :: a -> a -> a
366     "Integer remainder, satisfying ``(x `div` y)*y + (x `mod` y) = x``"    
367     mod :: a -> a -> a
368
369 """
370 The `Real` class is used for types that represent some approximation of real numbers. 
371 """
372 class (OrderedRing a) => Real a where
373     "Division"
374     (/) :: a -> a -> a
375     "Exponentation"
376     (^) :: a -> a -> a
377     "Pi (3.141592654...)"
378     pi  :: a
379     "Square root"
380     sqrt :: a -> a
381     "Exponent function"
382     exp :: a -> a
383     "Natural logarithm"
384     log :: a -> a 
385     "Sine"
386     sin :: a -> a
387     "Cosine"
388     cos :: a -> a
389     "Tangent"
390     tan :: a -> a
391     "Inverse sine"
392     asin :: a -> a
393     "Inverse cosine"
394     acos :: a -> a
395     "Inverse tangent."
396     atan :: a -> a
397     "Hyperbolic sine"
398     sinh :: a -> a
399     "Hyperbolic cosine"
400     cosh :: a -> a
401     "Hyperbolic tangent"
402     tanh :: a -> a
403     "Inverse hyberbolic sine"
404     asinh :: a -> a
405     "Inverse hyberbolic cosine"
406     acosh :: a -> a
407     "Inverse hyberbolic tangent"
408     atanh :: a -> a    
409     "The largest integer not greater than the given number"
410     floor :: a -> a
411     "The smallest integer not smaller than the given number"
412     ceil :: a -> a
413     round :: a -> Long
414     """
415     Two parameter version of `atan`. Its value is determined by the following
416     equations when (x,y) is a unit vector:
417     
418         x = cos (atan2 y x)
419         y = sin (atan2 y x)
420         
421     When x > 0,
422     
423         atan2 y x = atan (y/x)
424     """    
425     atan2 :: a -> a -> a
426     "Converts a `Double` value to a desired numeric type."
427     fromDouble :: Double -> a
428     "Converts the given number to `Double`"
429     toDouble :: a -> Double
430     
431     a ^ b = exp (b * log a)
432     
433     sinh x = 0.5 * (exp x - exp (neg x))
434     cosh x = 0.5 * (exp x + exp (neg x))
435     tanh x = (e2x - 1) / (e2x + 1) 
436       where
437         e2x = exp (2*x)
438        
439     asinh x = log (x + sqrt (x*x + one))
440     acosh x = log (x + sqrt (x*x - one))
441     atanh x = 0.5 * log ((one+x)/(one-x))
442     
443 /// Import mathematical functions ///
444
445 @private
446 importJava "java.lang.Math" where
447     @JavaName PI
448     piDouble :: Double
449     
450     @JavaName sin
451     sinDouble :: Double -> Double
452
453     @JavaName cos
454     cosDouble :: Double -> Double
455
456     @JavaName tan
457     tanDouble :: Double -> Double
458
459     @JavaName asin
460     asinDouble :: Double -> Double
461
462     @JavaName acos
463     acosDouble :: Double -> Double
464
465     @JavaName atan
466     atanDouble :: Double -> Double
467
468     @JavaName atan2    
469     atan2Double :: Double -> Double -> Double
470     
471     @JavaName sinh
472     sinhDouble :: Double -> Double
473
474     @JavaName cosh
475     coshDouble :: Double -> Double
476
477     @JavaName tanh
478     tanhDouble :: Double -> Double
479     
480     @JavaName exp
481     expDouble :: Double -> Double
482
483     @JavaName log
484     logDouble :: Double -> Double
485
486     @JavaName pow
487     powDouble :: Double -> Double -> Double
488
489     @JavaName sqrt
490     sqrtDouble :: Double -> Double
491     
492     @JavaName ceil
493     ceilDouble :: Double -> Double
494
495     @JavaName floor
496     floorDouble :: Double -> Double
497
498     @JavaName round
499     roundDouble :: Double -> Long
500     
501     @JavaName abs
502     absInteger :: Integer -> Integer
503
504     @JavaName abs
505     absLong :: Long -> Long
506
507     @JavaName abs
508     absFloat :: Float -> Float
509
510     @JavaName abs
511     absDouble :: Double -> Double
512         
513     @JavaName min
514     minInteger :: Integer -> Integer -> Integer
515
516     @JavaName min
517     minLong :: Long -> Long -> Long
518
519     @JavaName min
520     minFloat :: Float -> Float -> Float
521
522     @JavaName min
523     minDouble :: Double -> Double -> Double
524     
525     @JavaName max
526     maxInteger :: Integer -> Integer -> Integer
527
528     @JavaName max
529     maxLong :: Long -> Long -> Long
530
531     @JavaName max
532     maxFloat :: Float -> Float -> Float
533
534     @JavaName max
535     maxDouble :: Double -> Double -> Double
536
537 /// Integer ///
538
539 @private
540 importJava "java.lang.Byte" where
541     @JavaName toString
542     showByte :: Byte -> String
543     
544     @JavaName parseByte
545     readByte :: String -> Byte
546
547 instance Ord Byte where
548     (<) = Java.bcmplt
549     (<=) = Java.bcmple
550     (>) = Java.bcmpgt
551     (>=) = Java.bcmpge
552     
553 instance Additive Byte where
554     zero = Java.i2b Java.iconst_0
555     (+) = Java.badd
556     
557 instance Ring Byte where
558     neg = Java.bneg
559     (-) = Java.bsub
560     one = Java.i2b Java.iconst_1
561     (*) = Java.bmul
562     fromInteger = Java.i2b
563
564 instance Show Byte where
565     show = showByte
566     precedence v = if v >= 0 then 0 else 100
567
568 instance Read Byte where
569     read = readByte
570
571
572 @private
573 importJava "java.lang.Short" where
574     @JavaName toString
575     showShort :: Short -> String
576     
577     @JavaName parseShort
578     readShort :: String -> Short
579
580 instance Ord Short where
581     (<) = Java.scmplt
582     (<=) = Java.scmple
583     (>) = Java.scmpgt
584     (>=) = Java.scmpge
585     
586 instance Additive Short where
587     zero = Java.sconst_0
588     (+) = Java.sadd
589     
590 instance Ring Short where
591     neg = Java.sneg
592     (-) = Java.ssub
593     one = Java.sconst_1
594     (*) = Java.smul
595     fromInteger = Java.i2s
596
597 instance Show Short where
598     show = showShort
599     precedence v = if v >= 0 then 0 else 100
600
601 instance Read Short where
602     read = readShort
603     
604 /// Integer ///
605
606 @private
607 importJava "java.lang.Integer" where
608     @JavaName toString
609     showInteger :: Integer -> String
610     
611     @JavaName parseInt
612     readInteger :: String -> Integer
613
614 instance Ord Integer where
615     (<) = Java.icmplt
616     (<=) = Java.icmple
617     (>) = Java.icmpgt
618     (>=) = Java.icmpge
619
620 instance Additive Integer where
621     zero = Java.iconst_0
622     (+) = Java.iadd
623     
624 instance Ring Integer where
625     neg = Java.ineg
626     (-) = Java.isub
627     one = Java.iconst_1
628     (*) = Java.imul
629     fromInteger x = x
630     
631 instance OrderedRing Integer where
632     abs = absInteger
633     toInteger x = x
634
635 instance Integral Integer where
636     div = Java.idiv
637     mod = Java.irem
638
639 instance Show Integer where
640     show = showInteger
641     precedence v = if v >= 0 then 0 else 100
642
643 instance Read Integer where
644     read = readInteger
645
646 /// Long ///
647
648 @private
649 importJava "java.lang.Long" where
650     @JavaName toString
651     showLong :: Long -> String
652     
653     @JavaName parseLong
654     readLong :: String -> Long
655
656 instance Ord Long where
657     (<) = Java.lcmplt
658     (<=) = Java.lcmple
659     (>) = Java.lcmpgt
660     (>=) = Java.lcmpge
661
662 instance Additive Long where
663     zero = Java.lconst_0
664     (+) = Java.ladd
665     
666 instance Ring Long where
667     neg = Java.lneg
668     (-) = Java.lsub
669     one = Java.lconst_1
670     (*) = Java.lmul
671     fromInteger = Java.i2l
672     
673 instance OrderedRing Long where
674     abs = absLong
675     toInteger = Java.l2i
676
677 instance Integral Long where
678     div = Java.ldiv
679     mod = Java.lrem
680     
681 instance Show Long where
682     show = showLong
683     precedence v = if v >= 0 then 0 else 100
684
685 instance Read Long where
686     read = readLong
687     
688 /// Float ///
689
690 importJava "java.lang.Float" where
691     @private
692     @JavaName compare
693     compareFloat :: Float -> Float -> Integer
694
695     @private
696     @JavaName toString
697     showFloat :: Float -> String
698
699     @private
700     @JavaName parseFloat
701     readFloat :: String -> Float
702     
703     "Converts 32-bit floating point number to a 32-bit integer with the same byte level representation."
704     floatToIntBits :: Float -> Integer  
705
706 instance Ord Float where
707     compare = compareFloat
708     (<) = Java.fcmplt
709     (<=) = Java.fcmple
710     (>) = Java.fcmpgt
711     (>=) = Java.fcmpge
712
713 instance Additive Float where
714     zero = Java.fconst_0
715     (+) = Java.fadd
716     
717 instance Ring Float where
718     neg = Java.fneg
719     (-) = Java.fsub
720     one = Java.fconst_1
721     (*) = Java.fmul
722     fromInteger = Java.i2f
723
724 instance OrderedRing Float where
725     abs = absFloat
726     toInteger = Java.f2i
727     
728 instance Real Float where
729     (/) = Java.fdiv
730     x ^ y = Java.d2f (powDouble (Java.f2d x) (Java.f2d y))
731     pi = fromDouble piDouble
732     sqrt = Java.d2f . sqrtDouble . Java.f2d
733     exp = Java.d2f . expDouble . Java.f2d
734     log = Java.d2f . logDouble . Java.f2d
735     sin = Java.d2f . sinDouble . Java.f2d
736     cos = Java.d2f . cosDouble . Java.f2d
737     tan = Java.d2f . tanDouble . Java.f2d
738     asin = Java.d2f . asinDouble . Java.f2d
739     acos = Java.d2f . acosDouble . Java.f2d
740     atan = Java.d2f . atanDouble . Java.f2d
741     sinh = Java.d2f . sinhDouble . Java.f2d
742     cosh = Java.d2f . coshDouble . Java.f2d
743     tanh = Java.d2f . tanhDouble . Java.f2d
744     floor = Java.d2f . floorDouble . Java.f2d
745     ceil = Java.d2f . ceilDouble . Java.f2d
746     atan2 y x = Java.d2f (atan2Double (Java.f2d y) (Java.f2d x))
747     round = roundDouble . Java.f2d
748     fromDouble = Java.d2f
749     toDouble = Java.f2d
750
751 instance Show Float where
752     show = showFloat
753     precedence v = if v >= 0 then 0 else 100
754
755 instance Read Float where
756     read = readFloat
757     
758 /// Double ///
759
760 importJava "java.lang.Double" where
761     @private
762     @JavaName compare
763     compareDouble :: Double -> Double -> Integer
764     
765     @private
766     @JavaName toString
767     showDouble :: Double -> String
768     
769     @private
770     @JavaName parseDouble
771     readDouble :: String -> Double
772     
773     "Converts 64-bit floating point number to a 64-bit integer with the same byte level representation."
774     doubleToLongBits :: Double -> Long
775     
776     isFinite :: Double -> Boolean
777     isNaN :: Double -> Boolean
778     isInfinite :: Double -> Boolean
779
780 instance Ord Double where
781     compare = compareDouble
782     (<) = Java.dcmplt
783     (<=) = Java.dcmple
784     (>) = Java.dcmpgt
785     (>=) = Java.dcmpge 
786
787 instance Additive Double where
788     zero = Java.dconst_0
789     (+) = Java.dadd
790     
791 instance Ring Double where
792     neg = Java.dneg
793     (-) = Java.dsub
794     one = Java.dconst_1
795     (*) = Java.dmul
796     fromInteger = Java.i2d
797
798 instance OrderedRing Double where
799     abs = absDouble
800     toInteger = Java.d2i
801     
802 instance Real Double where
803     (/) = Java.ddiv
804     (^) = powDouble
805     pi = piDouble
806     sqrt = sqrtDouble
807     exp = expDouble
808     log = logDouble
809     sin = sinDouble
810     cos = cosDouble
811     tan = tanDouble
812     asin = asinDouble
813     acos = acosDouble
814     atan = atanDouble
815     sinh = sinhDouble
816     cosh = coshDouble
817     tanh = tanhDouble
818     floor = floorDouble
819     ceil = ceilDouble
820     atan2 = atan2Double
821     round = roundDouble
822     fromDouble x = x
823     toDouble x = x
824
825 instance Show Double where
826     show = showDouble
827     precedence v = if v >= 0 then 0 else 100
828
829 instance Read Double where
830     read = readDouble
831
832 /// Character ///
833
834 importJava "java.lang.Character" where
835     @JavaName toString
836     showCharacter :: Character -> String
837     
838     "Returns true, if the given character is a letter."
839     isLetter :: Character -> Boolean
840     
841     "Returns true, if the given character is a digit."
842     isDigit :: Character -> Boolean
843
844 instance Ord Character where
845     (<) = Java.ccmplt
846     (<=) = Java.ccmple
847     (>) = Java.ccmpgt
848     (>=) = Java.ccmpge
849     
850 instance Show Character where
851     sb <+ c = sb << "'" << showCharacter c << "'"
852     
853 "Adds a given integer to the character code."
854 addChar :: Character -> Integer -> Character
855 addChar = Java.cadd
856
857 "Subtracts a given integer from the character code."
858 subChar :: Character -> Character -> Integer
859 subChar = Java.csub
860
861 /// Functor ///
862
863 """
864 The `Functor` class is used for types that can be mapped over. Instances of `Functor` should satisfy the following laws:
865
866     fmap id  ==  id
867     fmap (f . g)  ==  fmap f . fmap g
868 """
869 class Functor f where
870     "Lifts a pure function to the given functor."
871     fmap :: (a -> b) -> f a -> f b
872 /*
873 class CoFunctor f where
874     comap :: (a -> b) -> f b -> f a
875 */
876 /// Applicative ///
877 /*
878 class (Functor f) => Applicative f where
879     return :: a -> f a
880     (<*>) :: f (a -> b) -> f a -> f b
881     (*>) :: f a -> f b -> f b
882     (<*) :: f a -> f b -> f a
883     
884     u *> v = pure (const id) <*> u <*> v
885     u <* v = pure const <*> u <*> v
886     fmap f x = pure f <*> x
887 */
888 /// Monad ///
889
890 """
891 The `Monad` class defines the basic operations over a monad, a concept from a branch of mathematics known as category theory.
892 From the perspective of a SCL programmer, however, it is best to think of a monad as an abstract datatype of actions.
893 SCL's `mdo expressions provide a convenient syntax for writing monadic expressions.
894
895 Instances of `Monad` should satisfy the following laws:
896
897     return a >>= k  ==  k a
898     m >>= return  ==  m
899     m >>= (\x -> k x >>= h)  ==  (m >>= k) >>= h
900     fmap f xs  ==  xs >>= return . f
901 """
902 class (Functor m) => Monad m where
903     "Inject a value into the monadic type."
904     return :: a -> m a
905     "Sequentially compose two actions, passing any value produced by the first as an argument to the second."
906     (>>=) :: m a -> (a -> m b) -> m b
907     """
908     The join function is the conventional monad join operator. It removes one level of monadic
909     structure.
910     
911     For lists, `join` concatenates a list of lists:
912     
913         join [[1,2], [3,4]] = [1, 2, 3, 4]
914     """
915     join :: m (m a) -> m a
916     join m = m >>= id
917
918 """
919 Sequentially compose two actions, discarding any value produced by the first, like sequencing operators
920 (such as the semicolon) in imperative languages."
921 """
922 @macro
923 (>>) :: Monad m => m a -> m b -> m b
924 a >> b = a >>= (\_ -> b)
925
926 "Left-to-right Kleisli composition of monads."
927 (>=>) :: Monad m => (a -> m b) -> (b -> m c) -> (a -> m c)
928 (f >=> g) x = (f x) >>= g 
929
930 "While loop. `while cond body` executes the `body` while the `cond` is true." 
931 @inline
932 while :: (<e> Boolean) -> (<e> a) -> <e> ()
933 while cond body = loop ()
934   where loop _ = if cond 
935                  then do body ; loop ()
936                  else ()
937
938 """
939 Sequences the given monadic value infinitely:
940
941     repeatForever m = m >> m >> m >> ...
942 """
943 repeatForever m = m >> repeatForever m
944
945 replicateM :: Monad m => Integer -> m a -> m [a]
946 replicateM count m = loop count emptyList
947   where
948     loop count l | count <= 0 = return l
949                  | otherwise  = mdo
950                      v <- m
951                      loop (count-1) (addList l v)
952
953 replicateM_ :: Monad m => Integer -> m a -> m ()
954 replicateM_ count m | count <= 0 = return ()
955                     | otherwise  = m >> replicateM_ (count-1) m
956
957 /// MonadZero ///
958
959 """
960 A class of monads with zero element satisfying
961
962     mzero >>= f = mzero
963 """ 
964 class (Monad m) => MonadZero m where
965     mzero :: m a
966
967 "Injects a boolean test to a type beloning to `MonadZero`."
968 guard :: MonadZero m => Boolean -> m ()
969 guard True = return ()
970 guard False = mzero
971
972 /// MonadPlus ///
973
974 """
975 A class of monads with associative binary operator `mplus` satisfying the following laws:  
976
977     mplus mzero b = b
978     mplus a mzero = a
979     mplus (mplus a b) c = mplus a (mplus b c)
980     mplus a b >>= k = mplus (a >>= k) (b >>= k)
981 """
982 class (MonadZero m) => MonadPlus m where
983     mplus :: m a -> m a -> m a
984
985 /// MonadOr ///
986
987 """
988 A class of monads with associative binary operator `morelse` satisfying the following laws:  
989
990     morelse mzero b = b
991     morelse a mzero = a
992     morelse (morelse a b) c = morelse a (morelse b c)
993     morelse (return a) b = return a
994 """
995 class (MonadZero m) => MonadOr m where
996     morelse :: m a -> m a -> m a
997
998 /// FunctorE ///
999
1000 """
1001 A class of types that can be mapped over with effectful mapping functions.
1002 """
1003 class (Functor f) => FunctorE f where
1004     """
1005     Applies the function to all elements of the container and
1006     returns the similarly shaped container with the results:
1007     
1008     For lists,
1009     
1010         map f [e1, e2, ..., eN] = [f e1, f e2, ..., f eN]
1011         
1012     for example
1013     
1014         map (*2) [1..5] = [2, 4, 6, 8, 10]
1015     """
1016     map :: (a -> <e> b) -> f a -> <e> (f b)
1017     "Calls the given function with all elements of the given container."
1018     iter :: (a -> <e> b) -> f a -> <e> ()
1019     "Calls the given function with all elements of the given container giving also the index of the element as a parameter."
1020     iterI :: (Integer -> a -> <e> b) -> f a -> <e> ()
1021
1022 "Iterates the elements of the given collection. Same as `iter` but parameters flipped." 
1023 for :: FunctorE f => f a -> (a -> <e> b) -> <e> ()
1024 @macro
1025 for l f = iter f l
1026
1027 "Iterates the elements of the given collection providing also the indices of the elements. Same as `iterI` but parameters flipped." 
1028 forI :: FunctorE f => f a -> (Integer -> a -> <e> b) -> <e> ()
1029 @macro
1030 forI l f = iterI f l
1031
1032 "`forN n f` calls `f` for all integers `0`, ..., `n-1`"
1033 @inline
1034 forN :: Integer -> (Integer -> <e> b) -> <e> ()
1035 forN n f = loop 0
1036   where
1037     loop i = if i < n
1038              then do f i ; loop (i+1)
1039              else ()
1040
1041 @inline
1042 mapI :: (Integer -> a -> <e> b) -> [a] -> <e> [b]
1043 mapI f l = build (\empty cons -> let
1044     len = length l
1045     loop i accum = if i < len
1046                    then loop (i+1) (cons accum (f i (l!i)))
1047                    else accum
1048   in loop 0 empty)
1049
1050 """
1051 `mapMaybe` combines `map` and `filter` functions. 
1052 It applies the given function to every element of the input list. If the result
1053 is `Just x`, then `x` is added to the resulting list.
1054
1055     mapMaybe f lst = [y | x <- lst, Just y = f x]
1056 """
1057 @inline
1058 mapMaybe :: (a -> <e> Maybe b) -> [a] -> <e> [b]
1059 mapMaybe f l = build (\empty cons -> foldl (\cur x -> match f x with Just v -> cons cur v ; _ -> cur) empty l)
1060
1061 """
1062 Applies the given function to all elements of the list. Produces two lists: the first contains all elements `x`
1063 for which the function returned `Left x` and the second list contains all elements `y` for which the function
1064 returned `Right y`.
1065 """
1066 mapEither :: (a -> <e> Either b c) -> [a] -> <e> ([b], [c])
1067 mapEither f list = runProc do
1068     l = newArrayList
1069     r = newArrayList
1070     for list (\x -> match f x with
1071         Left v -> addArrayList l v
1072         Right v -> addArrayList r v)
1073     (Java.unsafeCoerce l, Java.unsafeCoerce r)
1074
1075 "`replicate n v` returns a list of length `n` such that each element is a copy of `v`."
1076 @inline
1077 replicate :: Integer -> a -> [a]
1078 replicate n v = build (\empty cons ->
1079     let aux 0 l = l
1080         aux i l = aux (i-1) (cons l v)
1081     in aux n empty 
1082     )
1083
1084 /// FunctorM ///
1085
1086 class (FunctorE f) => FunctorM f where
1087     "`mapM f` is equivalent to `sequence . map f`."
1088     mapM :: Monad m => (a -> <e> m b) -> f a -> <e> m (f b)
1089     "Evaluate each action in the sequence from left to right, and collect the results."
1090     sequence :: Monad m => f (m a) -> m (f a) 
1091     mapM f l = sequence (map f l)
1092
1093 /// MonadE ///
1094
1095 class (FunctorE m, Monad m) => MonadE m where
1096     bindE :: m a -> (a -> <e> m b) -> <e> m b
1097
1098 instance MonadE Maybe where
1099     bindE Nothing  _ = Nothing
1100     bindE (Just v) f = f v
1101     
1102 instance MonadE (Either a) where
1103     bindE (Left v)  _ = Left v
1104     bindE (Right v) f = f v
1105
1106 instance MonadE [] where
1107     bindE l f = concatMap f l
1108     
1109 /// Category ///
1110
1111 "Identity function."
1112 id :: a -> a
1113 id x = x
1114
1115 """
1116 Ignores the given value. This function is used in a situation where a function returns
1117 a value in a context where the value is not expected.
1118 """
1119 @inline
1120 ignore :: a -> ()
1121 ignore _ = ()
1122
1123 @inline
1124 ignoreM :: a -> Maybe b
1125 ignoreM _ = Nothing
1126
1127 """
1128 Composes two functions
1129     (f . g) x = f (g x)
1130 """
1131 (.) :: (b -> <e> c) -> (a -> <e> b) -> (a -> <e> c)
1132 (f . g) x = f (g x)
1133
1134 /// Sequence ///
1135
1136 "A type class for sequences. All sequences must support indexing by integers."
1137 class /*(Additive a) =>*/ Sequence a where
1138     "Length of the sequence"
1139     length :: a -> Integer
1140     "`take n s` returns the first `n` elements of the sequence `s`."
1141     take :: Integer -> a -> a
1142     "`drop n s` removes the first `n` elements of the sequence `s`."
1143     drop :: Integer -> a -> a
1144     """
1145     `sub s begin end` returns a subsequence of `s` starting from
1146     index `begin` and ending just before index `end`.
1147     """ 
1148     sub :: a -> Integer -> Integer -> a
1149     
1150     take n v = sub v 0 (min n (length v))
1151     drop n v = sub v (min n len) len
1152       where
1153         len = length v 
1154
1155 instance Sequence [a] where
1156     length = lengthList
1157     sub = subList
1158     
1159 instance Sequence String where
1160     length = lengthString
1161     sub = subString        
1162
1163 class IndexedSequence f where
1164     "`seq ! i` returns the `i`th element of the sequence `seq`. Indexing starts from zero."
1165     (!) :: f a -> Integer -> a
1166
1167 "Returns the first element of a sequence"
1168 @inline
1169 first :: [a] -> a
1170 first l = l!0
1171
1172 "Returns the last element of a sequence"
1173 @inline
1174 last :: [a] -> a
1175 last l = l!(length l-1)
1176
1177 instance IndexedSequence [] where
1178     (!) = getList
1179
1180 /// Boolean ///
1181
1182 """
1183 Equivalent to the boolean value `True`. The value is meant to be used in
1184 guard patterns:
1185
1186     min a b | a < b     = a
1187             | otherwise = b 
1188 """
1189 @inline
1190 otherwise :: Boolean
1191 otherwise = True
1192
1193 instance Ord Boolean where
1194     compare False False = 0
1195     compare False True  = neg 1
1196     compare True  False = 1
1197     compare True  True  = 0
1198
1199 instance Show Boolean where
1200     show True = "True"
1201     show False = "False"
1202
1203 """
1204 Boolean conjunction (and). The function is a macro that evaluates the second parameter
1205 only if the first parameter is `True`.
1206
1207 <table>
1208 <tr><th>a</th><th>b</th><th>a && b</th></tr>
1209 <tr><td>True</td><td>True</td><td>True</td></tr>
1210 <tr><td>True</td><td>False</td><td>False</td></tr>
1211 <tr><td>False</td><td>not evaluated</td><td>False</td></tr>
1212 </table> 
1213 """
1214 @macro
1215 (&&) :: Boolean -> Boolean ->  Boolean
1216 a && b = if a then b else False
1217
1218 """
1219 Boolean disjunction (or). The function is a macro that evaluates the second parameter
1220 only if the first parameter is `False`.
1221
1222 <table>
1223 <tr><th>a</th><th>b</th><th>a || b</th></tr>
1224 <tr><td>True</td><td>not evaluated</td><td>True</td></tr>
1225 <tr><td>False</td><td>True</td><td>True</td></tr>
1226 <tr><td>False</td><td>False</td><td>False</td></tr>
1227 </table> 
1228 """
1229 @macro
1230 (||) :: Boolean -> Boolean -> Boolean
1231 a || b = if a then True else b
1232
1233 "Boolean negation"
1234 @inline
1235 not a = if a then False else True
1236
1237 /// Maybe ///
1238
1239 //data Maybe a = Nothing | Just a
1240
1241 "Given `Just x` this function returns `x`. If the parameter is `Nothing`, the function raises an exception."
1242 fromJust :: Maybe a -> a
1243 fromJust (Just a) = a
1244
1245 deriving instance (Ord a) => Ord (Maybe a)
1246 deriving instance (Show a) => Show (Maybe a)
1247
1248 instance Functor Maybe where
1249     fmap _ Nothing  = Nothing
1250     fmap f (Just x) = Just (f x)
1251
1252 instance FunctorE Maybe where
1253     map _ Nothing  = Nothing
1254     map f (Just x) = Just (f x)
1255     
1256     iter _ Nothing = ()
1257     iter f (Just x) = ignore (f x)
1258     
1259     iterI _ Nothing = ()
1260     iterI f (Just x) = ignore (f 0 x)
1261     
1262 instance Monad Maybe where    
1263     return x = Just x
1264
1265     @inline
1266     Nothing >>= _ = Nothing
1267     Just x  >>= f = f x
1268
1269     @inline
1270     join Nothing  = Nothing
1271     join (Just x) = x
1272
1273 instance MonadZero Maybe where
1274     mzero = Nothing
1275
1276 instance MonadOr Maybe where
1277     morelse a@(Just _) _ = a
1278     morelse _ b = b
1279
1280 "`execJust v f` executes the function `f` with parameter value `x`, if `v=Just x`. If `v=Nothing`, the function does nothing."
1281 @inline
1282 execJust :: Maybe a -> (a -> <e> b) -> <e> ()
1283 execJust maybeValue procedure = match maybeValue with
1284     Just v -> ignore $ procedure v
1285     _ -> ()
1286
1287 "`fromMaybe def v` returns `def` if `v=Nothing` and `x` if `v=Just x`."
1288 @inline
1289 fromMaybe :: a -> Maybe a -> a
1290 fromMaybe default maybeValue = match maybeValue with
1291     Just v -> v
1292     _ -> default
1293
1294 "`maybe def f v` returns `def` if `v=Nothing` and `f x` if `v=Just x`."
1295 @inline
1296 maybe :: b -> (a -> <e> b) -> Maybe a -> <e> b
1297 maybe n _ Nothing  = n
1298 maybe _ f (Just x) = f x
1299
1300 """
1301 Provides a default value if the first parameter is Nothing.
1302 The default value is evaluated only if needed. The function
1303 can be used as an operator and is right associative so that
1304 the following is possible:
1305
1306     tryWithTheFirstMethod
1307         `orElse` tryWithTheSecondMethod
1308         `orElse` fail "Didn't succeed."
1309 """
1310 @inline
1311 orElse :: Maybe a -> (<e> a) -> <e> a
1312 orElse (Just x) _   = x
1313 orElse Nothing  def = def
1314
1315 @inline
1316 orElseM :: Maybe a -> (<e> Maybe a) -> <e> Maybe a
1317 orElseM mx@(Just x) _   = mx
1318 orElseM Nothing     def = def
1319
1320 /// Either ///
1321
1322 """
1323 The Either type represents values with two possibilities: a value of type `Either a b` is either `Left a` or `Right b`.
1324
1325 The `Either` type is sometimes used to represent a value which is either correct or an error; by convention, the `Left` constructor
1326 is used to hold an error value and the `Right` constructor is used to hold a correct value (mnemonic: "right" also means "correct").
1327 """
1328 @JavaType "org.simantics.scl.runtime.either.Either"
1329 data Either a b =
1330     @JavaType "org.simantics.scl.runtime.either.Left"
1331     @FieldNames [value]
1332     Left a
1333   | @JavaType "org.simantics.scl.runtime.either.Right"
1334     @FieldNames [value]
1335     Right b
1336
1337 deriving instance (Ord a, Ord b) => Ord (Either a b)
1338 deriving instance (Show a, Show b) => Show (Either a b)
1339
1340 instance Functor (Either a) where
1341     fmap _ (Left x)  = Left x
1342     fmap f (Right y) = Right (f y)
1343
1344 instance FunctorE (Either a) where
1345     map _ (Left x)  = Left x
1346     map f (Right y) = Right (f y)
1347     
1348     iter _ (Left x) = ()
1349     iter f (Right y) = ignore (f y)
1350     
1351     iterI _ (Left x) = ()
1352     iterI f (Right y) = ignore (f 0 y)
1353         
1354 instance Monad (Either b) where
1355     return y = Right y
1356
1357     Left x  >>= _ = Left x
1358     Right y >>= f = f y
1359
1360     join (Left x)  = Left x
1361     join (Right y) = y
1362     
1363 /// String ///
1364
1365 importJava "java.lang.String" where
1366     @private
1367     @JavaName "concat"
1368     concatString :: String -> String -> String
1369     @private
1370     @JavaName "compareTo"
1371     compareString :: String -> String -> Integer
1372     @private
1373     @JavaName "length"
1374     lengthString :: String -> Integer
1375
1376     """
1377     `replaceString original pattern replacement` replaces all occurrences of `pattern` in the string by `replacement`.
1378     """ 
1379     @JavaName replace
1380     replaceString :: String -> String -> String -> String
1381     
1382     @private
1383     @JavaName split
1384     splitString_ :: String -> String -> Array String
1385     
1386     """
1387     `indexOf string s` finds the first occurrence of `s` from `string` and returns its index.
1388     If the `s` does not occur in the string, return `-1`."
1389     """
1390     @JavaName indexOf
1391     indexOf :: String -> String -> Integer
1392     
1393     "Works like `indexOf` but starts searching from the given index instead of the beginning of the string."
1394     @JavaName indexOf
1395     indexOfStartingFrom :: String -> String -> Integer -> Integer
1396     
1397     "Works like `indexOf` but returns the index of the last occurrence."
1398     @JavaName lastIndexOf
1399     lastIndexOf :: String -> String -> Integer
1400     
1401     "Works like `lastIndexOf` but starts searching from the given index instead of the end of the string."
1402     @JavaName lastIndexOf
1403     lastIndexOfStartingFrom :: String -> String -> Integer -> Integer
1404     
1405     @private
1406     @JavaName substring
1407     subString :: String -> Integer -> Integer -> String
1408
1409     """
1410     `regionMatches str1 offset1 str2 offset2 len` tests whether
1411     `sub str1 offset1 (offset1+len) == sub str2 offset2 (offset2+len)`.
1412     """
1413     regionMatches :: String -> Integer -> String -> Integer -> Integer -> Boolean
1414
1415     "`startsWith string prefix` returns true if the string begins with the given prefix."
1416     startsWith :: String -> String -> Boolean
1417     
1418     "`endsWith string suffix` returns true if the string ends with the given prefix."
1419     endsWith :: String -> String -> Boolean
1420     
1421     "Removes leading and trailing whitespace from the string."
1422     trim :: String -> String
1423     
1424     "`contains string s` returns true if `string` contains `s` as a substring."
1425     contains :: String -> String -> Boolean
1426     
1427     "`charAt string i` returns the `i`th character of the string."
1428     charAt :: String -> Integer -> Character
1429     
1430     "Converts all letters of the string to lower case."
1431     toLowerCase :: String -> String
1432     "Converts all letters of the string to upper case."
1433     toUpperCase :: String -> String
1434     
1435     "Creates a string from a vector of characters."
1436     @JavaName "<init>"
1437     string :: Vector Character -> String
1438     
1439     getBytes :: String -> String -> ByteArray
1440
1441 getBytesUTF8 :: String -> ByteArray
1442 getBytesUTF8 str = getBytes str "UTF-8"
1443
1444 instance Ord String where
1445     compare = compareString
1446     
1447 instance Additive String where
1448     zero = ""
1449     (+) = concatString
1450     sum ss = runProc (StringBuilder.toString $ foldl StringBuilder.appendString StringBuilder.new ss)
1451
1452 @private
1453 importJava "org.simantics.scl.runtime.string.StringEscape" where
1454     appendEscapedString :: StringBuilder.T -> String -> <Proc> StringBuilder.T
1455
1456 instance Show String where
1457     showForPrinting = id
1458     sb <+ v = (appendEscapedString (sb << "\"") v) << "\""
1459
1460 instance Read String where
1461     read str = str
1462     
1463 @deprecated "Instead of 'splitString text pattern', write 'split pattern text' (note change in the parameter order)." 
1464 "`splitString text pattern` splits the string into a list of string where the parts are sepratated in the original list by the given pattern."
1465 splitString :: String -> String -> [String]
1466 splitString source pattern = arrayToList $ splitString_ source pattern
1467
1468 """
1469 `split pattern text` splits `text` around matches of the given regular expression `pattern`.
1470
1471 This function works as if by invoking the two-argument split method with the given expression and a limit argument of zero. Trailing empty strings are therefore not included in the resulting array.
1472
1473 The string "boo:and:foo", for example, yields the following results with these expressions:
1474
1475     Regex   Result
1476     :       { "boo", "and", "foo" }
1477     o       { "b", "", ":and:f" }
1478 """
1479 split :: String -> String -> [String]
1480 split pattern text = arrayToList $ splitString_ text pattern
1481
1482 /// Tuple0 ///
1483
1484 instance Ord () where
1485     compare () () = 0
1486
1487 instance Additive () where
1488     zero = ()
1489     () + () = ()
1490
1491 instance Show () where
1492     show () = "()"
1493
1494 /// Tuple2 ///
1495
1496 "Gives the first element of a pair."
1497 @inline
1498 fst :: (a,b) -> a
1499 fst (x,y) = x
1500
1501 "Gives the second element of a pair."
1502 @inline
1503 snd :: (a,b) -> b
1504 snd (x,y) = y
1505
1506 @inline
1507 mapFst :: (a -> b) -> (a,c) -> (b,c)
1508 mapFst f (x,y) = (f x, y)
1509
1510 @inline
1511 mapSnd :: (a -> b) -> (c,a) -> (c,b)
1512 mapSnd f (x,y) = (x, f y)
1513
1514 instance (Ord a, Ord b) => Ord (a, b) where
1515     compare (a0, b0) (a1, b1) = compare a0 a1 &<& compare b0 b1
1516
1517 instance (Additive a, Additive b) => Additive (a, b) where
1518     zero = (zero, zero)
1519     (a0, b0) + (a1, b1) = (a0+a1, b0+b1)
1520
1521 instance Functor ((,) a) where
1522     fmap f (a,b) = (a, f b)
1523     
1524 instance (Show a, Show b) => Show (a, b) where
1525     sb <+ (x, y) = sb << "(" <+ x << ", " <+ y << ")"
1526
1527 /// Tuple3 ///
1528
1529 instance (Ord a, Ord b, Ord c) => Ord (a, b, c) where
1530     compare (a0, b0, c0) (a1, b1, c1) = compare a0 a1 &<& compare b0 b1 &<& compare c0 c1
1531
1532 instance (Additive a, Additive b, Additive c) => Additive (a, b, c) where
1533     zero = (zero, zero, zero)
1534     (a0, b0, c0) + (a1, b1, c1) = (a0+a1, b0+b1, c0+c1)
1535
1536 instance Functor ((,,) a b) where
1537     fmap f (a,b,c) = (a, b, f c)
1538
1539 instance (Show a, Show b, Show c) => Show (a, b, c) where
1540     sb <+ (x, y, z) = sb << "(" <+ x << ", " <+ y << ", " <+ z << ")"
1541
1542 /// Tuple4 ///
1543
1544 instance (Ord a, Ord b, Ord c, Ord d) => Ord (a, b, c, d) where
1545     compare (a0, b0, c0, d0) (a1, b1, c1, d1) = 
1546         compare a0 a1 &<& compare b0 b1 &<& compare c0 c1 &<& compare d0 d1
1547
1548 instance (Additive a, Additive b, Additive c, Additive d) => Additive (a, b, c, d) where
1549     zero = (zero, zero, zero, zero)
1550     (a0, b0, c0, d0) + (a1, b1, c1, d1) = (a0+a1, b0+b1, c0+c1, d0+d1)
1551
1552 instance Functor ((,,,) a b c) where
1553     fmap f (a,b,c,d) = (a, b, c, f d)
1554
1555 instance (Show a, Show b, Show c, Show d) => Show (a, b, c, d) where
1556     sb <+ (x, y, z, w) = sb << "(" <+ x << ", " <+ y << ", " <+ z << ", " <+ w << ")"
1557     
1558 /// Tuple5 ///
1559
1560 instance (Ord a, Ord b, Ord c, Ord d, Ord e) => Ord (a, b, c, d, e) where
1561     compare (a0, b0, c0, d0, e0) (a1, b1, c1, d1, e1) = 
1562         compare a0 a1 &<& compare b0 b1 &<& compare c0 c1 &<& compare d0 d1 &<& compare e0 e1
1563     
1564 instance (Additive a, Additive b, Additive c, Additive d, Additive e) => Additive (a, b, c, d, e) where
1565     zero = (zero, zero, zero, zero, zero)
1566     (a0, b0, c0, d0, e0) + (a1, b1, c1, d1, e1) = (a0+a1, b0+b1, c0+c1, d0+d1, e0+e1)
1567
1568 instance Functor ((,,,,) a b c d) where
1569     fmap f (a,b,c,d,e) = (a, b, c, d, f e)
1570
1571 /// Lists ///
1572
1573 instance (Ord a) => Ord [a] where
1574     compare a b = loop 0 
1575       where
1576         lA = length a
1577         lB = length b
1578         loop i = if i >= lA
1579                  then (if i >= lB then 0 else -1)
1580                  else if i >= lB
1581                  then 1
1582                  else compare (a!i) (b!i) &<& loop (i+1)
1583
1584 instance Functor [] where
1585     fmap = mapList
1586
1587 instance FunctorE [] where
1588     map = mapEList
1589     iter = iterList
1590     iterI = iterIList
1591         
1592 instance Monad [] where
1593     return x = singletonList x
1594     l >>= f  = concatMap f l
1595     join l   = l >>= id
1596
1597 instance MonadZero [] where
1598     mzero = emptyList
1599
1600 instance MonadPlus [] where
1601     mplus = appendList
1602
1603 instance Additive [a] where
1604     zero = emptyList
1605     (+) = appendList
1606
1607 instance FunctorM [] where
1608     sequence = foldl (\m mel -> m >>= \l -> mel >>= \el -> return (addList l el)) (return emptyList)
1609     mapM f l = sequence (map f l)
1610
1611 "Appends the string representations of all elements of the list to the string builder and separates the values with the given separator."
1612 printWithSeparator :: Show a => StringBuilder.T -> String -> [a] -> <Proc> StringBuilder.T
1613 printWithSeparator sb sep l = loop 0
1614   where
1615     len = length l
1616     loop i = if i >= len then sb
1617              else do
1618                  (if i==0 then sb else sb << sep) <+ l!i
1619                  loop (i+1)
1620
1621 """
1622 Joins the string representations of the list of values with the given separator.
1623
1624 See [intercalate](#intercalate) for an alternative that works with Strings
1625 and doesn't escape its arguments.
1626 """
1627 joinWithSeparator :: Show a => String -> [a] -> String
1628 joinWithSeparator separator values = runProc ( 
1629     StringBuilder.toString $ printWithSeparator StringBuilder.new separator values)
1630
1631
1632 """
1633 The intercalate function takes a String and a list of Strings
1634 and concatenates the list after interspersing the first argument
1635 between each element of the list.
1636
1637 See also more generic [joinWithSeparator](#joinWithSeparator)
1638 which escapes its arguments using `show`.
1639 """
1640 intercalate :: String -> [String] -> String
1641 intercalate separator strings = do
1642     l = length strings
1643     if l == 0
1644     then ""
1645     else if l == 1
1646     then strings!0
1647     else runProc do
1648         sb = StringBuilder.new
1649         sb << strings!0
1650         loop i | i == l = ()
1651                | otherwise = do
1652             sb << separator << strings!i
1653             loop (i+1)
1654         loop 1
1655         StringBuilder.toString sb
1656
1657 instance (Show a) => Show [a] where
1658     sb <+ l = do 
1659         len = length l
1660         loop i = if i < len 
1661                  then do 
1662                      if (i>0) then sb << ", " else sb
1663                      sb <+ l!i
1664                      loop (i+1)
1665                  else sb << "]"
1666         sb << "[" 
1667         loop 0                 
1668
1669 importJava "java.util.List" where
1670     "`getList l i` returns the `i`th element of the list `l`. Indexing starts from zero. You can also use the `!` infix function for this purpose."
1671     @JavaName get
1672     getList :: [a] -> Integer -> a
1673
1674     @private
1675     @JavaName size
1676     lengthList :: [a] -> Integer
1677
1678     @private
1679     subList :: [a] -> Integer -> Integer -> [a]
1680
1681     @private
1682     isEmpty :: [a] -> Boolean
1683     
1684 @private    
1685 importJava "java.util.Collections" where
1686     emptyList :: [a]
1687     //singletonList :: a -> [a]
1688
1689 /*
1690 @inline
1691 emptyList :: [a]
1692 emptyList = build (\empty cons -> empty)
1693 */
1694
1695 "Creates a list with exectly one element."
1696 @inline
1697 singletonList :: a -> [a]
1698 singletonList v = build (\empty cons -> cons empty v)
1699
1700 /*
1701 // foldl f i (a + b) = foldl f (foldl f i a) b 
1702
1703 appendList :: [a] -> [a] -> [a]
1704 appendList a b = build (\empty cons -> foldl cons (foldl cons empty a) b)
1705 */
1706
1707 importJava "org.simantics.scl.runtime.list.ShareableList" where
1708     "Concatenates two lists."
1709     @private
1710     @JavaName "concat"
1711     appendList :: [a] -> [a] -> [a]
1712     
1713     "Adds the given value to the end of the list."
1714     @JavaName "add"   
1715     addList :: [a] -> a -> [a]
1716
1717 @private
1718 importJava "java.util.ArrayList" where
1719     data ArrayList a
1720
1721     @JavaName "<init>"
1722     newArrayList :: <Proc> ArrayList a
1723     
1724     @JavaName add
1725     addArrayList :: ArrayList a -> a -> <Proc> ()
1726
1727 """
1728 A primitive for constructing a list by `empty` and `cons` operations given to the function given as a parameter to this function.
1729 For example:
1730
1731     build (\empty cons -> cons (cons (cons empty 1) 2) 3)
1732     
1733 produces
1734
1735     [1, 2, 3]
1736     
1737 The SCL compiler makes the following optimization when encountering `build` and `foldl` functions after inlining:
1738
1739     foldl f i (build g) = g i f
1740 """
1741 @inline 2
1742 build :: forall b e2. (forall a e1. a -> (a -> b -> <e1> a) -> <e1,e2> a) -> <e2> [b]
1743 build f = runProc do
1744     l = newArrayList
1745     f () (\_ v -> addArrayList l v)
1746     Java.unsafeCoerce l
1747
1748 "A specific implementation of `map` for lists."
1749 @private
1750 @inline
1751 mapEList :: (a -> <e> b) -> [a] -> <e> [b]
1752 mapEList f l = build (\empty cons -> foldl (\cur x -> cons cur (f x)) empty l) 
1753
1754 "A specific implementation of `fmap` for lists."
1755 @inline
1756 mapList :: (a -> b) -> [a] -> [b]
1757 mapList f l = build (\empty cons -> foldl (\cur x -> cons cur (f x)) empty l) 
1758  
1759 "`guardList v` returns a singleton `[()]` if `v=True` and the empty list if `v=False`."
1760 @inline
1761 guardList :: Boolean -> [()]
1762 guardList cond = build (\empty cons -> if cond then cons empty () else empty) 
1763
1764 """
1765 `concatMap` combines `map` and `join` functions.
1766 It maps the elements of a given list to lists with the given function and concatenates the results.
1767
1768     concatMap f lst = join (map f lst) = [y | x <- lst, y <- f x] 
1769 """
1770 @inline
1771 concatMap :: (a -> <e> [b]) -> [a] -> <e> [b]
1772 concatMap f l = build (\empty cons -> foldl (\cur le -> foldl cons cur (f le)) empty l)
1773
1774 """
1775 Applies the given function to the elements of the lists until the function returns something
1776 else than `Nothing`. This return value is also returned as a result of this function.
1777 """
1778 @inline
1779 mapFirst :: (a -> <e> Maybe b) -> [a] -> <e> Maybe b
1780 mapFirst f l = loop 0 
1781   where
1782     len = length l
1783     loop i = if i == len
1784              then Nothing
1785              else match f (l!i) with
1786                  r @ (Just _) -> r
1787                  Nothing -> loop (i+1)
1788
1789 """
1790     foldl op initialValue list
1791     
1792 applies a binary operator `op` to all elements of `list` from left to right
1793 starting with `initialValue`. For example, 
1794
1795     foldl op init [x1, x2, x3, x4] = (((init `op` x1) `op` x2) `op` x3) `op` x4
1796 """
1797 @inline 2
1798 foldl :: forall a b e. (a -> b -> <e> a) -> a -> [b] -> <e> a
1799 foldl f initial l = loop initial 0
1800   where
1801     len = length l
1802     loop cur i = if i==len
1803                  then cur
1804                  else loop (f cur (l!i)) (i+1)
1805
1806 foldlI :: forall a b e. (Integer -> a -> b -> <e> a) -> a -> [b] -> <e> a
1807 foldlI f initial l = loop initial 0
1808   where
1809     len = length l
1810     loop cur i = if i==len
1811                  then cur
1812                  else loop (f i cur (l!i)) (i+1)
1813
1814 scanl :: (b -> a -> <e> b) -> b -> [a] -> <e> [b]
1815 scanl f initial l = build (\empty cons -> let
1816     len = length l
1817     loop cur i accum = let nl = cons accum cur
1818                            in if i==len
1819                            then nl
1820                             else loop (f cur (l!i)) (i+1) nl
1821   in loop initial 0 empty)
1822   
1823 "`foldr` is defined like `foldl` but it process the list from right to left."
1824 @inline
1825 foldr :: (b -> a -> <e> a) -> a -> [b] -> <e> a
1826 foldr f initial l = loop initial (length l - 1)
1827   where
1828     loop cur i = if i < 0
1829                  then cur
1830                  else loop (f (l!i) cur) (i-1)
1831
1832 foldr1 :: (a -> a -> <e> a) -> [a] -> <e> a
1833 foldr1 f l = loop (l!(len-1)) (len-2)
1834   where
1835     len = length l
1836     loop cur i = if i < 0
1837                  then cur
1838                  else loop (f (l!i) cur) (i-1)
1839
1840 """
1841 `filter pred lst` returns those elements of `lst` that the predicate `pred` accepts. For example
1842
1843     filter (> 3) [1, 2, 3, 4, 5, 6] = [4, 5, 6]
1844 """ 
1845 @inline
1846 filter :: (a -> <e> Boolean) -> [a] -> <e> [a]
1847 filter p l = build (\empty cons -> foldl (\cur x -> if p x then cons cur x else cur) empty l)
1848
1849 """
1850 Takes those elements of the input list that match `(Just x)` and adds the contents to the resulting list. For example,
1851
1852     filterJust [Just 1, Nothing, Just 5] = [1, 5] 
1853 """
1854 @inline
1855 filterJust :: [Maybe a] -> [a]
1856 filterJust l = build (\empty cons -> foldl (\cur x -> match x with Just v -> cons cur v ; _ -> cur) empty l)
1857
1858 listToMaybe :: [a] -> Maybe a
1859 listToMaybe l = if isEmpty l then Nothing else Just (l!0)
1860
1861 maybeToList :: Maybe a -> [a]
1862 maybeToList (Just a) = [a]
1863 maybeToList _ = [] 
1864
1865 """
1866 `takeWhile p l`, returns the longest prefix (possibly empty) of list `l` of elements that satisfy `p`
1867 """
1868 takeWhile :: (a -> <e> Boolean) -> [a] -> <e> [a]
1869 takeWhile f l = loop 0 
1870   where
1871     len = length l
1872     loop i | i == len  = l
1873            | f (l!i)   = loop (i+1)
1874            | otherwise = take i l
1875
1876 partition :: (a -> <e> Boolean) -> [a] -> <e> ([a], [a])
1877 partition p l = runProc do
1878     res1 = newArrayList
1879     res2 = newArrayList
1880     for l (\el ->
1881         if p el
1882         then addArrayList res1 el
1883         else addArrayList res2 el
1884     )
1885     (Java.unsafeCoerce res1, Java.unsafeCoerce res2)
1886
1887 """
1888 `range begin end` produces a list of consecutive integers starting from `begin` and ending to `end` (including `end`).
1889 The compiler supports syntactic sugar `[begin..end]` for this function.
1890 """
1891 @inline    
1892 range :: Integer -> Integer -> [Integer]
1893 range first last = build (\empty cons -> do
1894     loop i cur = if i > last then cur else loop (i+1) (cons cur i)
1895     loop first empty)
1896
1897 "A specific implementation of `iter` for lists."
1898 @inline
1899 iterList :: (a -> <e> b) -> [a] -> <e> ()
1900 iterList f l = foldl (\_ x -> ignore (f x)) () l
1901
1902 "A specific implementation of `iterI` for lists."
1903 @inline
1904 iterIList :: (Integer -> a -> <e> b) -> [a] -> <e> ()
1905 iterIList f l = do foldl (\i x -> do f i x ; i+1) 0 l ; () 
1906
1907 """
1908 Generates a list from a given starting state and iteration function.
1909 For example
1910
1911     let nextState 0 = Nothing
1912         nextState i = Just (i, i `div` 2)
1913     in  unfoldr nextState 30
1914         
1915 produces
1916
1917     [30, 15, 7, 3, 1]
1918 """
1919 @inline
1920 unfoldr :: (b -> <e> Maybe (a, b)) -> b -> <e> [a]
1921 unfoldr f s = build (\empty cons -> do
1922     loop s cur =
1923         match f s with
1924             Just (el,newS) -> loop newS (cons cur el)
1925             _ -> cur
1926     loop s empty)
1927
1928 importJava "org.simantics.scl.runtime.Lists" where
1929     /*
1930     @private
1931     @JavaName map
1932     mapList :: (a -> b) -> [a] -> [b]    
1933     @private
1934     @JavaName map
1935     mapEList :: (a -> <e> b) -> [a] -> <e> [b]
1936     @private
1937     @JavaName iter
1938     iterList :: (a -> <e> ()) -> [a] -> <e> ()
1939     concatMap :: (a -> <e> [b]) -> [a] -> <e> [b]
1940     */ 
1941     """
1942     Combines two lists into one list of pairs. The length of the resulting list is the length of the smallest input list.
1943     
1944         zip [1, 2, 3, 4, 5] ['a', 'b', 'c'] = [(1, 'a'), (2, 'b'), (3, 'c')]
1945     """
1946     zip :: [a] -> [b] -> [(a,b)]
1947     "Combines two lists by using the given function for combining the elements. The length of the resulting list is the length of the smallest input list."
1948     zipWith :: (a -> b -> <e> c) -> [a] -> [b] -> <e> [c]
1949     """
1950     Produces two lists from one list of pairs.
1951     
1952         unzip [(1, 'a'), (2, 'b'), (3, 'c')] = ([1, 2, 3], ['a', 'b', 'c'])
1953     """
1954     unzip :: [(a,b)] -> ([a],[b])
1955     
1956     //"@filter p l@ returns those elements of @l@ that the predicate @p@ accepts." 
1957     //filter :: (a -> <e> Boolean) -> [a] -> <e> [a]
1958     //filterJust :: [Maybe a] -> [a]
1959     /*
1960     foldl :: (a -> b -> <e> a) -> a -> [b] -> <e> a
1961     */
1962     "Like `foldl` but assumes that the list is non-empty so the initial is not needed."
1963     foldl1 :: (a -> a -> <e> a) -> [a] -> <e> a
1964     //unfoldr :: (b -> <e> Maybe (a, b)) -> b -> <e> [a]
1965     
1966     "Sorts the list using the given comparator."
1967     sortWith :: (a -> a -> <e> Integer) -> [a] -> <e> [a]
1968     
1969     """
1970     Given a list of key-value pairs, the function produces a function that finds a value
1971     efficiently for the given key.
1972     """
1973     index :: [(a,b)] -> a -> Maybe b
1974     
1975     """
1976     Given a list of elements, the function produces its characteristic function.
1977     """
1978     indexSet :: [a] -> a -> Boolean
1979     
1980     """
1981     Given a list of values and a function computing a key for each value, the function produces a function that finds a value
1982     effeciently for the given key.
1983     """
1984     indexBy ::  (a -> <e> b) -> [a] -> <e> (b -> Maybe a)
1985     
1986     "Works like `index` but uses the given functions as hash codes and equality."
1987     indexWith :: (a -> Integer) -> (a -> a -> Boolean) -> [(a,b)] -> a -> Maybe b
1988     
1989     "Groups a list values by a key computed by the given function."
1990     groupBy :: (a -> <e> b) -> [a] -> <e> [(b, [a])]
1991     
1992     "Groups a list of key-value pairs by the keys."
1993     group :: [(a,b)] -> [(a, [b])]
1994
1995     "Composition of index and groupBy."
1996     indexGroupBy :: (a -> <e> b) -> [a] -> <e> (b -> [a])
1997     
1998     "Composition of index and group."
1999     indexGroup :: [(a,b)] -> a -> [b]
2000     
2001     groupWith :: (b -> Integer) -> (b -> b -> Boolean) -> (a -> <e> b) -> (a -> <e> c) -> [a] -> <e> [(b, [c])]
2002     
2003     "Removes duplicates (all but the first occurrence) from the list but otherwise preserves the order of the elements."
2004     unique :: [a] -> [a]
2005     
2006     "Like `unique`, but uses the given function for finding the key values used for uniqueness testing."
2007     uniqueBy :: (a -> <e> b) -> [a] -> <e> [a]
2008
2009     "Works like `unique` but uses the given function for equality tests."
2010     uniqueWith :: (a -> a -> Boolean) -> [a] -> [a]
2011     
2012     "Works like `\\\\` but uses the given function for equality tests."
2013     deleteAllBy :: (a -> a -> Boolean) -> [a] -> [a] -> [a]
2014     
2015     @private
2016     listDifference :: [a] -> [a] -> [a]
2017     
2018     //range :: Integer -> Integer -> [Integer]
2019     
2020     //build :: (forall a. a -> (a -> b -> <e> a) -> <e> a) -> <e> [b]
2021
2022 "`elem el lst` return true, if `el` occurs in the list `lst`."
2023 elem :: a -> [a] -> Boolean
2024 elem el l = loop 0
2025   where
2026     len = length l
2027     loop i | i < len = if el == l!i
2028                        then True
2029                        else loop (i+1)
2030            | otherwise = False
2031
2032 "`elemMaybe v1 (Just v2)` returns true if `v1 == v2`. `elemMaybe v1 Nothing` is always false."
2033 elemMaybe :: a -> Maybe a -> Boolean
2034 elemMaybe el m = match m with
2035     Just el2 -> el == el2
2036     Nothing -> False
2037
2038 "`elemIndex el lst` returns the index of the first element in the given list `lst` which is equal (by ==) to the query element, or Nothing if there is no such element."
2039 elemIndex :: a -> [a] -> Maybe Integer
2040 elemIndex el l = loop 0
2041   where
2042     len = length l
2043     loop i | i < len = if el == l!i
2044                        then Just i
2045                        else loop (i+1)
2046            | otherwise = Nothing
2047
2048 """
2049 Computes a list that contains only elements that belongs to both input lists.
2050 """
2051 intersect :: [a] -> [a] -> [a]
2052 intersect a b = filter f a
2053   where
2054     f e = elem e b
2055
2056 "Reverses a given list. For example, `reverse [1,2,3] = [3,2,1]`"
2057 reverse :: [a] -> [a]
2058 reverse l = [l!(len-i) | i <- [1..len]]
2059   where
2060     len = length l
2061
2062 """
2063 Transposes the rows and columns of its argument. For example,
2064
2065     transpose [[1,2,3],[4,5,6]] == [[1,4],[2,5],[3,6]]
2066     transpose [[1,2],[3,4,5]] == [[1,3],[2,4],[5]]
2067 """
2068 transpose :: [[a]] -> [[a]]
2069 transpose xss = [[xs!i | xs <- xss, i < length xs]
2070                 | i <- [0..maximum [length xs | xs <- xss]-1]]
2071
2072 "Works like `unfoldr` but generates the list from right to left."
2073 unfoldl :: (b -> <e> Maybe (a, b)) -> b -> <e> [a]
2074 unfoldl f seed = reverse $ unfoldr f seed
2075
2076 "Removes the first element of the list, if the list is non-empty."
2077 tail :: [a] -> [a]
2078 tail l = if len < 2 then emptyList else subList l 1 len 
2079   where 
2080     len = length l
2081
2082 "Tries to find the given key from the list of key-value pairs and returns the corresponding value."
2083 lookup ::  a -> [(a, b)] -> Maybe b
2084 lookup el l = do
2085     len = length l
2086     loop i = if i < len 
2087              then match l!i with
2088                (a,b) | a == el   -> Just b
2089                      | otherwise -> loop (i+1)
2090              else Nothing
2091     loop 0
2092
2093 "Conjunction over a list."
2094 @inline
2095 and :: [Boolean] -> Boolean
2096 and = foldl (&&) True
2097
2098 "Disjunction over a list."
2099 @inline
2100 or :: [Boolean] -> Boolean
2101 or  = foldl (||) False
2102
2103 """
2104 `any pred lst` tests whether the predicate `pred` holds some element of `lst`.
2105 It returns immediately when it encounters the first value satisfying the predicate.
2106 """ 
2107 any :: (a -> <e> Boolean) -> [a] -> <e> Boolean
2108 any p =  or . map p
2109
2110 """
2111 `all pred lst` tests whether the predicate `pred` holds for all elements of `lst`.
2112 It returns immediately when it encounters the first value not satisfying the predicate.
2113 """ 
2114 all :: (a -> <e> Boolean) -> [a] -> <e> Boolean
2115 all p =  and . map p
2116
2117 """
2118 Returns the first element of the list satisfying the given condition,
2119 or `Nothing` if there is no such element.
2120 """
2121 findFirst :: (a -> <e> Boolean) -> [a] -> <e> Maybe a
2122 findFirst p l = loop 0
2123   where
2124     len = length l
2125     loop i = if i < len 
2126              then let el = l!i in 
2127                   if p el 
2128                   then Just el 
2129                   else loop (i+1)
2130              else Nothing
2131     loop 0
2132
2133
2134 """
2135 Sorts the given list using its default order.
2136 """
2137 @inline
2138 sort :: Ord a => [a] -> [a]
2139 sort = sortWith compare
2140
2141 """
2142 Sorts the lists by the values computed by the first function.
2143 For example
2144
2145     sortBy snd [(1,5), (2,3), (3,4)] = [(2,3), (3,4), (1,5)] 
2146 """
2147 @inline
2148 sortBy :: Ord b => (a -> <e> b) -> [a] -> <e> [a]
2149 sortBy f l = sortWith (\x y -> compare (f x) (f y)) l
2150 // This is faster if f is slow, but will generate more auxiliary structures
2151 //sortBy f l = map snd (sortWith (\(x,_) (y,_) -> compare x y) [(f x, x) | x <- l])
2152
2153 "`a \\\\ b` removes all elements of `b` from the list `a`."
2154 (\\) :: [a] -> [a] -> [a]
2155 (\\) = listDifference
2156
2157 /// Dynamic ///
2158
2159 importJava "java.lang.Object" where
2160     "A data type that can represent any value."
2161     data Dynamic
2162     
2163     @private
2164     @JavaName toString
2165     showDynamic :: Dynamic -> String
2166
2167 instance Show Dynamic where
2168     show = showDynamic
2169
2170 "Converts a value to `Dynamic` type."
2171 toDynamic :: a -> Dynamic
2172 toDynamic = Java.unsafeCoerce
2173
2174 "Converts a `Dynamic` value to a required value, or fails if the conversion is not possible."
2175 importJava "org.simantics.scl.compiler.runtime.ValueConversion" where
2176     fromDynamic :: Typeable a => Dynamic -> a
2177
2178 /// Procedures ///
2179
2180 importJava "org.simantics.scl.runtime.procedure.Ref" where
2181     "A mutable reference to a value of type `a`."
2182     data Ref a
2183     
2184     "Creates a new reference with the given initial value."
2185     @JavaName "<init>"
2186     ref :: a -> <Proc> (Ref a)
2187     
2188     "Returns the current value of the reference."
2189     @JavaName "value"
2190     getRef :: Ref a -> <Proc> a
2191     
2192     "Sets a new value for the reference."
2193     @JavaName "<set>value"
2194     (:=) :: Ref a -> a -> <Proc> ()
2195
2196 instance Show (Ref a) where
2197     show _ = "<reference>"
2198
2199 importJava "org.simantics.scl.runtime.reporting.SCLReporting" where
2200     "Prints the given string to the console."
2201     @JavaName "print"
2202     printString :: String -> <Proc> ()
2203     "Prints an error message to the console."
2204     printError :: String -> <Proc> ()
2205     "Reports that certain amount of work has been done for the current task."
2206     didWork :: Double -> <Proc> ()
2207     """
2208     `printingToFile "fileName" expression` executes the `expression` so that all its console prints
2209     are written to the file given as a first parameter.
2210     """
2211     printingToFile :: String -> (<e> a) -> <e> a
2212     """
2213     `printErrorsAsNormalPrints expression` executes the `expression` so that all its error prints
2214     are printed as normal prints. This is useful mainly in testing scripts for checking that the implementations
2215     give proper error messages with invalid inputs.
2216     """
2217     printErrorsAsNormalPrints :: (<e> a) -> <e> a
2218     """
2219     `disablePrintingForCommand expression` executes the `expression` so that it does not print return values.
2220     Errors are printed normally.
2221     """
2222     disablePrintingForCommand :: (<e> a) -> <e> a
2223     
2224
2225 importJava "org.simantics.scl.runtime.procedure.Procedures" where
2226     "Returns `True` if the current thread has been interrupted."
2227     isInterrupted :: <Proc> Boolean
2228     "Checks whether the current thread has been interrupted and throws an exception if it is."
2229     checkInterrupted :: <Proc> ()
2230     "Generates a random identifier."
2231     generateUID :: <Proc> String
2232     
2233     "Executes the given expression and catches certain class of exceptions (specified by the catch handler that is given as a second parameter.)"
2234     @JavaName catch_
2235     catch :: VecComp ex => (<e,Exception> a) -> (ex -> <e> a) -> <e> a
2236
2237 importJava "java.lang.Throwable" where
2238     data Throwable
2239     @private
2240     @JavaName toString
2241     showThrowable :: Throwable -> String
2242     @private
2243     @JavaName getMessage 
2244     getMessageThrowable :: Throwable -> String
2245     @private
2246     @JavaName getCause 
2247     getCauseThrowable :: Throwable -> Maybe Throwable
2248 importJava "java.lang.Exception" where
2249     data Exception
2250     @private
2251     @JavaName toString
2252     showException :: Exception -> String
2253
2254 instance Show Throwable where
2255     show = showThrowable
2256 instance Show Exception where
2257     show = showException
2258
2259 class Throwable e where
2260     toThrowable :: e -> Throwable
2261
2262 messageOfException :: Throwable e => e -> String
2263 messageOfException = getMessageThrowable . toThrowable
2264
2265 causeOfException :: Throwable e => e -> Maybe Throwable
2266 causeOfException = getCauseThrowable . toThrowable
2267
2268 instance Throwable Throwable where
2269     toThrowable = id
2270 instance Throwable Exception where
2271     toThrowable = Java.unsafeCoerce
2272
2273 "Prints the given value in the console."
2274 @inline
2275 print :: Show a => a -> <Proc> ()
2276 print v = printString (showForPrinting v)
2277 /*
2278 instance Show TypeRep where
2279     sb <+ (TApply (TCon "Builtin" "[]") b) = 
2280         sb << "[" <+ b << "]"
2281     sb <+ (TApply (TApply (TCon "Builtin" "(,)") c1) c2) = 
2282         sb << "(" <+ c1 << "," <+ c2 << ")"
2283     sb <+ (TApply (TApply (TApply (TCon "Builtin" "(,,)") c1) c2) c3) = 
2284         sb << "(" <+ c1 << "," <+ c2 << "," <+ c3 << ")"
2285     sb <+ (TApply (TApply (TApply (TApply (TCon "Builtin" "(,,,)") c1) c2) c3) c4) =
2286         sb << "(" <+ c1 << "," <+ c2 << "," <+ c3 << "," <+ c4 << ")" 
2287     
2288     sb <+ (TCon _ name) = sb << name
2289     sb <+ (TApply a b) = sb <+ Par 1 a << " " <+ Par 2 b
2290     sb <+ (TFun a b) = sb <+ Par 1 a << " -> " <+ b
2291     
2292     precedence (TCon _ _) = 0
2293     precedence (TFun _ _) = 2
2294     precedence (TApply a _) = if isSpecialType a then 0 else 1
2295       where
2296         isSpecialType (TCon "Builtin" "[]") = True
2297         isSpecialType (TCon "Builtin" "()") = True
2298         isSpecialType (TCon "Builtin" "(,)") = True
2299         isSpecialType (TCon "Builtin" "(,,)") = True
2300         isSpecialType (TCon "Builtin" "(,,,)") = True
2301         isSpecialType (TApply a _) = isSpecialType a
2302 */
2303
2304 // Type
2305
2306 @private
2307 importJava "org.simantics.scl.compiler.types.Type" where
2308     @JavaName toString
2309     showType :: Type -> String
2310
2311 importJava "org.simantics.scl.compiler.types.Types" where
2312     removeForAll :: Type -> Type
2313     
2314 instance Show Type where
2315     show = showType