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