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 l = l!0
1170
1171 "Returns the last element of a sequence"
1172 @inline
1173 last l = l!(length l-1)
1174
1175 instance IndexedSequence [] where
1176     (!) = getList
1177
1178 /// Boolean ///
1179
1180 """
1181 Equivalent to the boolean value `True`. The value is meant to be used in
1182 guard patterns:
1183
1184     min a b | a < b     = a
1185             | otherwise = b
1186 """
1187 @inline
1188 otherwise :: Boolean
1189 otherwise = True
1190
1191 instance Ord Boolean where
1192     compare False False = 0
1193     compare False True  = neg 1
1194     compare True  False = 1
1195     compare True  True  = 0
1196
1197 instance Show Boolean where
1198     show True = "True"
1199     show False = "False"
1200
1201 """
1202 Boolean conjunction (and). The function is a macro that evaluates the second parameter
1203 only if the first parameter is `True`.
1204
1205 <table>
1206 <tr><th>a</th><th>b</th><th>a && b</th></tr>
1207 <tr><td>True</td><td>True</td><td>True</td></tr>
1208 <tr><td>True</td><td>False</td><td>False</td></tr>
1209 <tr><td>False</td><td>not evaluated</td><td>False</td></tr>
1210 </table>
1211 """
1212 @macro
1213 (&&) :: Boolean -> Boolean ->  Boolean
1214 a && b = if a then b else False
1215
1216 """
1217 Boolean disjunction (or). The function is a macro that evaluates the second parameter
1218 only if the first parameter is `False`.
1219
1220 <table>
1221 <tr><th>a</th><th>b</th><th>a || b</th></tr>
1222 <tr><td>True</td><td>not evaluated</td><td>True</td></tr>
1223 <tr><td>False</td><td>True</td><td>True</td></tr>
1224 <tr><td>False</td><td>False</td><td>False</td></tr>
1225 </table>
1226 """
1227 @macro
1228 (||) :: Boolean -> Boolean -> Boolean
1229 a || b = if a then True else b
1230
1231 "Boolean negation"
1232 @inline
1233 not a = if a then False else True
1234
1235 /// Maybe ///
1236
1237 //data Maybe a = Nothing | Just a
1238
1239 "Given `Just x` this function returns `x`. If the parameter is `Nothing`, the function raises an exception."
1240 fromJust :: Maybe a -> a
1241 fromJust (Just a) = a
1242
1243 deriving instance (Ord a) => Ord (Maybe a)
1244 deriving instance (Show a) => Show (Maybe a)
1245
1246 instance Functor Maybe where
1247     fmap _ Nothing  = Nothing
1248     fmap f (Just x) = Just (f x)
1249
1250 instance FunctorE Maybe where
1251     map _ Nothing  = Nothing
1252     map f (Just x) = Just (f x)
1253
1254     iter _ Nothing = ()
1255     iter f (Just x) = ignore (f x)
1256
1257     iterI _ Nothing = ()
1258     iterI f (Just x) = ignore (f 0 x)
1259
1260 instance Monad Maybe where
1261     return x = Just x
1262
1263     @inline
1264     Nothing >>= _ = Nothing
1265     Just x  >>= f = f x
1266
1267     @inline
1268     join Nothing  = Nothing
1269     join (Just x) = x
1270
1271 instance MonadZero Maybe where
1272     mzero = Nothing
1273
1274 instance MonadOr Maybe where
1275     morelse a@(Just _) _ = a
1276     morelse _ b = b
1277
1278 "`execJust v f` executes the function `f` with parameter value `x`, if `v=Just x`. If `v=Nothing`, the function does nothing."
1279 @inline
1280 execJust :: Maybe a -> (a -> <e> b) -> <e> ()
1281 execJust maybeValue procedure = match maybeValue with
1282     Just v -> ignore $ procedure v
1283     _ -> ()
1284
1285 "`fromMaybe def v` returns `def` if `v=Nothing` and `x` if `v=Just x`."
1286 @inline
1287 fromMaybe :: a -> Maybe a -> a
1288 fromMaybe default maybeValue = match maybeValue with
1289     Just v -> v
1290     _ -> default
1291
1292
1293 """
1294 Provides a default value if the first parameter is Nothing.
1295 The default value is evaluated only if needed. The function
1296 can be used as an operator and is right associative so that
1297 the following is possible:
1298
1299     tryWithTheFirstMethod
1300         `orElse` tryWithTheSecondMethod
1301         `orElse` fail "Didn't succeed."
1302 """
1303 @inline
1304 orElse :: Maybe a -> (<e> a) -> <e> a
1305 orElse (Just x) _   = x
1306 orElse Nothing  def = def
1307
1308 @inline
1309 orElseM :: Maybe a -> (<e> Maybe a) -> <e> Maybe a
1310 orElseM mx@(Just x) _   = mx
1311 orElseM Nothing     def = def
1312
1313 /// Either ///
1314
1315 """
1316 The Either type represents values with two possibilities: a value of type `Either a b` is either `Left a` or `Right b`.
1317
1318 The `Either` type is sometimes used to represent a value which is either correct or an error; by convention, the `Left` constructor
1319 is used to hold an error value and the `Right` constructor is used to hold a correct value (mnemonic: "right" also means "correct").
1320 """
1321 @JavaType "org.simantics.scl.runtime.either.Either"
1322 data Either a b =
1323     @JavaType "org.simantics.scl.runtime.either.Left"
1324     @FieldNames [value]
1325     Left a
1326   | @JavaType "org.simantics.scl.runtime.either.Right"
1327     @FieldNames [value]
1328     Right b
1329
1330 deriving instance (Ord a, Ord b) => Ord (Either a b)
1331 deriving instance (Show a, Show b) => Show (Either a b)
1332
1333 instance Functor (Either a) where
1334     fmap _ (Left x)  = Left x
1335     fmap f (Right y) = Right (f y)
1336
1337 instance FunctorE (Either a) where
1338     map _ (Left x)  = Left x
1339     map f (Right y) = Right (f y)
1340
1341     iter _ (Left x) = ()
1342     iter f (Right y) = ignore (f y)
1343
1344     iterI _ (Left x) = ()
1345     iterI f (Right y) = ignore (f 0 y)
1346
1347 instance Monad (Either b) where
1348     return y = Right y
1349
1350     Left x  >>= _ = Left x
1351     Right y >>= f = f y
1352
1353     join (Left x)  = Left x
1354     join (Right y) = y
1355
1356 /// String ///
1357
1358 importJava "java.lang.String" where
1359     @private
1360     @JavaName "concat"
1361     concatString :: String -> String -> String
1362     @private
1363     @JavaName "compareTo"
1364     compareString :: String -> String -> Integer
1365     @private
1366     @JavaName "length"
1367     lengthString :: String -> Integer
1368
1369     """
1370     `replaceString original pattern replacement` replaces all occurrences of `pattern` in the string by `replacement`.
1371     """
1372     @JavaName replace
1373     replaceString :: String -> String -> String -> String
1374
1375     @private
1376     @JavaName split
1377     splitString_ :: String -> String -> Array String
1378
1379     """
1380     `indexOf string s` finds the first occurrence of `s` from `string` and returns its index.
1381     If the `s` does not occur in the string, return `-1`."
1382     """
1383     @JavaName indexOf
1384     indexOf :: String -> String -> Integer
1385
1386     "Works like `indexOf` but starts searching from the given index instead of the beginning of the string."
1387     @JavaName indexOf
1388     indexOfStartingFrom :: String -> String -> Integer -> Integer
1389
1390     "Works like `indexOf` but returns the index of the last occurrence."
1391     @JavaName lastIndexOf
1392     lastIndexOf :: String -> String -> Integer
1393
1394     "Works like `lastIndexOf` but starts searching from the given index instead of the end of the string."
1395     @JavaName lastIndexOf
1396     lastIndexOfStartingFrom :: String -> String -> Integer -> Integer
1397
1398     @private
1399     @JavaName substring
1400     subString :: String -> Integer -> Integer -> String
1401
1402     """
1403     `regionMatches str1 offset1 str2 offset2 len` tests whether
1404     `sub str1 offset1 (offset1+len) == sub str2 offset2 (offset2+len)`.
1405     """
1406     regionMatches :: String -> Integer -> String -> Integer -> Integer -> Boolean
1407
1408     "`startsWith string prefix` returns true if the string begins with the given prefix."
1409     startsWith :: String -> String -> Boolean
1410
1411     "`endsWith string suffix` returns true if the string ends with the given prefix."
1412     endsWith :: String -> String -> Boolean
1413
1414     "Removes leading and trailing whitespace from the string."
1415     trim :: String -> String
1416
1417     "`contains string s` returns true if `string` contains `s` as a substring."
1418     contains :: String -> String -> Boolean
1419
1420     "`charAt string i` returns the `i`th character of the string."
1421     charAt :: String -> Integer -> Character
1422
1423     "Converts all letters of the string to lower case."
1424     toLowerCase :: String -> String
1425     "Converts all letters of the string to upper case."
1426     toUpperCase :: String -> String
1427
1428     "Creates a string from a vector of characters."
1429     @JavaName "<init>"
1430     string :: Vector Character -> String
1431
1432     getBytes :: String -> String -> ByteArray
1433
1434 getBytesUTF8 :: String -> ByteArray
1435 getBytesUTF8 str = getBytes str "UTF-8"
1436
1437 instance Ord String where
1438     compare = compareString
1439
1440 instance Additive String where
1441     zero = ""
1442     (+) = concatString
1443     sum ss = runProc (StringBuilder.toString $ foldl StringBuilder.appendString StringBuilder.new ss)
1444
1445 @private
1446 importJava "org.simantics.scl.runtime.string.StringEscape" where
1447     appendEscapedString :: StringBuilder.T -> String -> <Proc> StringBuilder.T
1448
1449 instance Show String where
1450     showForPrinting = id
1451     sb <+ v = (appendEscapedString (sb << "\"") v) << "\""
1452
1453 instance Read String where
1454     read str = str
1455
1456 @deprecated "Instead of 'splitString text pattern', write 'split pattern text' (note change in the parameter order)."
1457 "`splitString text pattern` splits the string into a list of string where the parts are sepratated in the original list by the given pattern."
1458 splitString :: String -> String -> [String]
1459 splitString source pattern = arrayToList $ splitString_ source pattern
1460
1461 """
1462 `split pattern text` splits `text` around matches of the given regular expression `pattern`.
1463
1464 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.
1465
1466 The string "boo:and:foo", for example, yields the following results with these expressions:
1467
1468     Regex   Result
1469     :       { "boo", "and", "foo" }
1470     o       { "b", "", ":and:f" }
1471 """
1472 split :: String -> String -> [String]
1473 split pattern text = arrayToList $ splitString_ text pattern
1474
1475 /// Tuple0 ///
1476
1477 instance Ord () where
1478     compare () () = 0
1479
1480 instance Additive () where
1481     zero = ()
1482     () + () = ()
1483
1484 instance Show () where
1485     show () = "()"
1486
1487 /// Tuple2 ///
1488
1489 "Gives the first element of a pair."
1490 @inline
1491 fst :: (a,b) -> a
1492 fst (x,y) = x
1493
1494 "Gives the second element of a pair."
1495 @inline
1496 snd :: (a,b) -> b
1497 snd (x,y) = y
1498
1499 @inline
1500 mapFst :: (a -> b) -> (a,c) -> (b,c)
1501 mapFst f (x,y) = (f x, y)
1502
1503 @inline
1504 mapSnd :: (a -> b) -> (c,a) -> (c,b)
1505 mapSnd f (x,y) = (x, f y)
1506
1507 instance (Ord a, Ord b) => Ord (a, b) where
1508     compare (a0, b0) (a1, b1) = compare a0 a1 &<& compare b0 b1
1509
1510 instance (Additive a, Additive b) => Additive (a, b) where
1511     zero = (zero, zero)
1512     (a0, b0) + (a1, b1) = (a0+a1, b0+b1)
1513
1514 instance Functor ((,) a) where
1515     fmap f (a,b) = (a, f b)
1516
1517 instance (Show a, Show b) => Show (a, b) where
1518     sb <+ (x, y) = sb << "(" <+ x << ", " <+ y << ")"
1519
1520 /// Tuple3 ///
1521
1522 instance (Ord a, Ord b, Ord c) => Ord (a, b, c) where
1523     compare (a0, b0, c0) (a1, b1, c1) = compare a0 a1 &<& compare b0 b1 &<& compare c0 c1
1524
1525 instance (Additive a, Additive b, Additive c) => Additive (a, b, c) where
1526     zero = (zero, zero, zero)
1527     (a0, b0, c0) + (a1, b1, c1) = (a0+a1, b0+b1, c0+c1)
1528
1529 instance Functor ((,,) a b) where
1530     fmap f (a,b,c) = (a, b, f c)
1531
1532 instance (Show a, Show b, Show c) => Show (a, b, c) where
1533     sb <+ (x, y, z) = sb << "(" <+ x << ", " <+ y << ", " <+ z << ")"
1534
1535 /// Tuple4 ///
1536
1537 instance (Ord a, Ord b, Ord c, Ord d) => Ord (a, b, c, d) where
1538     compare (a0, b0, c0, d0) (a1, b1, c1, d1) =
1539         compare a0 a1 &<& compare b0 b1 &<& compare c0 c1 &<& compare d0 d1
1540
1541 instance (Additive a, Additive b, Additive c, Additive d) => Additive (a, b, c, d) where
1542     zero = (zero, zero, zero, zero)
1543     (a0, b0, c0, d0) + (a1, b1, c1, d1) = (a0+a1, b0+b1, c0+c1, d0+d1)
1544
1545 instance Functor ((,,,) a b c) where
1546     fmap f (a,b,c,d) = (a, b, c, f d)
1547
1548 instance (Show a, Show b, Show c, Show d) => Show (a, b, c, d) where
1549     sb <+ (x, y, z, w) = sb << "(" <+ x << ", " <+ y << ", " <+ z << ", " <+ w << ")"
1550
1551 /// Tuple5 ///
1552
1553 instance (Ord a, Ord b, Ord c, Ord d, Ord e) => Ord (a, b, c, d, e) where
1554     compare (a0, b0, c0, d0, e0) (a1, b1, c1, d1, e1) =
1555         compare a0 a1 &<& compare b0 b1 &<& compare c0 c1 &<& compare d0 d1 &<& compare e0 e1
1556
1557 instance (Additive a, Additive b, Additive c, Additive d, Additive e) => Additive (a, b, c, d, e) where
1558     zero = (zero, zero, zero, zero, zero)
1559     (a0, b0, c0, d0, e0) + (a1, b1, c1, d1, e1) = (a0+a1, b0+b1, c0+c1, d0+d1, e0+e1)
1560
1561 instance Functor ((,,,,) a b c d) where
1562     fmap f (a,b,c,d,e) = (a, b, c, d, f e)
1563
1564 /// Lists ///
1565
1566 instance (Ord a) => Ord [a] where
1567     compare a b = loop 0
1568       where
1569         lA = length a
1570         lB = length b
1571         loop i = if i >= lA
1572                  then (if i >= lB then 0 else -1)
1573                  else if i >= lB
1574                  then 1
1575                  else compare (a!i) (b!i) &<& loop (i+1)
1576
1577 instance Functor [] where
1578     fmap = mapList
1579
1580 instance FunctorE [] where
1581     map = mapEList
1582     iter = iterList
1583     iterI = iterIList
1584
1585 instance Monad [] where
1586     return x = singletonList x
1587     l >>= f  = concatMap f l
1588     join l   = l >>= id
1589
1590 instance MonadZero [] where
1591     mzero = emptyList
1592
1593 instance MonadPlus [] where
1594     mplus = appendList
1595
1596 instance Additive [a] where
1597     zero = emptyList
1598     (+) = appendList
1599
1600 instance FunctorM [] where
1601     sequence = foldl (\m mel -> m >>= \l -> mel >>= \el -> return (addList l el)) (return emptyList)
1602     mapM f l = sequence (map f l)
1603
1604 "Appends the string representations of all elements of the list to the string builder and separates the values with the given separator."
1605 printWithSeparator :: Show a => StringBuilder.T -> String -> [a] -> <Proc> StringBuilder.T
1606 printWithSeparator sb sep l = loop 0
1607   where
1608     len = length l
1609     loop i = if i >= len then sb
1610              else do
1611                  (if i==0 then sb else sb << sep) <+ l!i
1612                  loop (i+1)
1613
1614 """
1615 Joins the string representations of the list of values with the given separator.
1616
1617 See [intercalate](#intercalate) for an alternative that works with Strings
1618 and doesn't escape its arguments.
1619 """
1620 joinWithSeparator :: Show a => String -> [a] -> String
1621 joinWithSeparator separator values = runProc (
1622     StringBuilder.toString $ printWithSeparator StringBuilder.new separator values)
1623
1624
1625 """
1626 The intercalate function takes a String and a list of Strings
1627 and concatenates the list after interspersing the first argument
1628 between each element of the list.
1629
1630 See also more generic [joinWithSeparator](#joinWithSeparator)
1631 which escapes its arguments using `show`.
1632 """
1633 intercalate :: String -> [String] -> String
1634 intercalate separator strings = do
1635     l = length strings
1636     if l == 0
1637     then ""
1638     else if l == 1
1639     then strings!0
1640     else runProc do
1641         sb = StringBuilder.new
1642         sb << strings!0
1643         loop i | i == l = ()
1644                | otherwise = do
1645             sb << separator << strings!i
1646             loop (i+1)
1647         loop 1
1648         StringBuilder.toString sb
1649
1650 instance (Show a) => Show [a] where
1651     sb <+ l = do
1652         len = length l
1653         loop i = if i < len
1654                  then do
1655                      if (i>0) then sb << ", " else sb
1656                      sb <+ l!i
1657                      loop (i+1)
1658                  else sb << "]"
1659         sb << "["
1660         loop 0
1661
1662 importJava "java.util.List" where
1663     "`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."
1664     @JavaName get
1665     getList :: [a] -> Integer -> a
1666
1667     @private
1668     @JavaName size
1669     lengthList :: [a] -> Integer
1670
1671     @private
1672     subList :: [a] -> Integer -> Integer -> [a]
1673
1674     @private
1675     isEmpty :: [a] -> Boolean
1676
1677 @private
1678 importJava "java.util.Collections" where
1679     emptyList :: [a]
1680     //singletonList :: a -> [a]
1681
1682 /*
1683 @inline
1684 emptyList :: [a]
1685 emptyList = build (\empty cons -> empty)
1686 */
1687
1688 "Creates a list with exectly one element."
1689 @inline
1690 singletonList :: a -> [a]
1691 singletonList v = build (\empty cons -> cons empty v)
1692
1693 /*
1694 // foldl f i (a + b) = foldl f (foldl f i a) b
1695
1696 appendList :: [a] -> [a] -> [a]
1697 appendList a b = build (\empty cons -> foldl cons (foldl cons empty a) b)
1698 */
1699
1700 importJava "org.simantics.scl.runtime.list.ShareableList" where
1701     "Concatenates two lists."
1702     @private
1703     @JavaName "concat"
1704     appendList :: [a] -> [a] -> [a]
1705
1706     "Adds the given value to the end of the list."
1707     @JavaName "add"
1708     addList :: [a] -> a -> [a]
1709
1710 @private
1711 importJava "java.util.ArrayList" where
1712     data ArrayList a
1713
1714     @JavaName "<init>"
1715     newArrayList :: <Proc> ArrayList a
1716
1717     @JavaName add
1718     addArrayList :: ArrayList a -> a -> <Proc> ()
1719
1720 """
1721 A primitive for constructing a list by `empty` and `cons` operations given to the function given as a parameter to this function.
1722 For example:
1723
1724     build (\empty cons -> cons (cons (cons empty 1) 2) 3)
1725
1726 produces
1727
1728     [1, 2, 3]
1729
1730 The SCL compiler makes the following optimization when encountering `build` and `foldl` functions after inlining:
1731
1732     foldl f i (build g) = g i f
1733 """
1734 @inline 2
1735 build :: forall b e2. (forall a e1. a -> (a -> b -> <e1> a) -> <e1,e2> a) -> <e2> [b]
1736 build f = runProc do
1737     l = newArrayList
1738     f () (\_ v -> addArrayList l v)
1739     Java.unsafeCoerce l
1740
1741 "A specific implementation of `map` for lists."
1742 @private
1743 @inline
1744 mapEList :: (a -> <e> b) -> [a] -> <e> [b]
1745 mapEList f l = build (\empty cons -> foldl (\cur x -> cons cur (f x)) empty l)
1746
1747 "A specific implementation of `fmap` for lists."
1748 @inline
1749 mapList :: (a -> b) -> [a] -> [b]
1750 mapList f l = build (\empty cons -> foldl (\cur x -> cons cur (f x)) empty l)
1751
1752 "`guardList v` returns a singleton `[()]` if `v=True` and the empty list if `v=False`."
1753 @inline
1754 guardList :: Boolean -> [()]
1755 guardList cond = build (\empty cons -> if cond then cons empty () else empty)
1756
1757 """
1758 `concatMap` combines `map` and `join` functions.
1759 It maps the elements of a given list to lists with the given function and concatenates the results.
1760
1761     concatMap f lst = join (map f lst) = [y | x <- lst, y <- f x]
1762 """
1763 @inline
1764 concatMap :: (a -> <e> [b]) -> [a] -> <e> [b]
1765 concatMap f l = build (\empty cons -> foldl (\cur le -> foldl cons cur (f le)) empty l)
1766
1767 """
1768 Applies the given function to the elements of the lists until the function returns something
1769 else than `Nothing`. This return value is also returned as a result of this function.
1770 """
1771 @inline
1772 mapFirst :: (a -> <e> Maybe b) -> [a] -> <e> Maybe b
1773 mapFirst f l = loop 0
1774   where
1775     len = length l
1776     loop i = if i == len
1777              then Nothing
1778              else match f (l!i) with
1779                  r @ (Just _) -> r
1780                  Nothing -> loop (i+1)
1781
1782 """
1783     foldl op initialValue list
1784
1785 applies a binary operator `op` to all elements of `list` from left to right
1786 starting with `initialValue`. For example,
1787
1788     foldl op init [x1, x2, x3, x4] = (((init `op` x1) `op` x2) `op` x3) `op` x4
1789 """
1790 @inline 2
1791 foldl :: forall a b e. (a -> b -> <e> a) -> a -> [b] -> <e> a
1792 foldl f initial l = loop initial 0
1793   where
1794     len = length l
1795     loop cur i = if i==len
1796                  then cur
1797                  else loop (f cur (l!i)) (i+1)
1798
1799 foldlI :: forall a b e. (Integer -> a -> b -> <e> a) -> a -> [b] -> <e> a
1800 foldlI f initial l = loop initial 0
1801   where
1802     len = length l
1803     loop cur i = if i==len
1804                  then cur
1805                  else loop (f i cur (l!i)) (i+1)
1806
1807 scanl :: (b -> a -> <e> b) -> b -> [a] -> <e> [b]
1808 scanl f initial l = build (\empty cons -> let
1809     len = length l
1810     loop cur i accum = let nl = cons accum cur
1811                            in if i==len
1812                            then nl
1813                             else loop (f cur (l!i)) (i+1) nl
1814   in loop initial 0 empty)
1815
1816 "`foldr` is defined like `foldl` but it process the list from right to left."
1817 @inline
1818 foldr :: (b -> a -> <e> a) -> a -> [b] -> <e> a
1819 foldr f initial l = loop initial (length l - 1)
1820   where
1821     loop cur i = if i < 0
1822                  then cur
1823                  else loop (f (l!i) cur) (i-1)
1824
1825 foldr1 :: (a -> a -> <e> a) -> [a] -> <e> a
1826 foldr1 f l = loop (l!(len-1)) (len-2)
1827   where
1828     len = length l
1829     loop cur i = if i < 0
1830                  then cur
1831                  else loop (f (l!i) cur) (i-1)
1832
1833 """
1834 `filter pred lst` returns those elements of `lst` that the predicate `pred` accepts. For example
1835
1836     filter (> 3) [1, 2, 3, 4, 5, 6] = [4, 5, 6]
1837 """
1838 @inline
1839 filter :: (a -> <e> Boolean) -> [a] -> <e> [a]
1840 filter p l = build (\empty cons -> foldl (\cur x -> if p x then cons cur x else cur) empty l)
1841
1842 """
1843 Takes those elements of the input list that match `(Just x)` and adds the contents to the resulting list. For example,
1844
1845     filterJust [Just 1, Nothing, Just 5] = [1, 5]
1846 """
1847 @inline
1848 filterJust :: [Maybe a] -> [a]
1849 filterJust l = build (\empty cons -> foldl (\cur x -> match x with Just v -> cons cur v ; _ -> cur) empty l)
1850
1851 listToMaybe :: [a] -> Maybe a
1852 listToMaybe l = if isEmpty l then Nothing else Just (l!0)
1853
1854 maybeToList :: Maybe a -> [a]
1855 maybeToList (Just a) = [a]
1856 maybeToList _ = []
1857
1858 """
1859 `takeWhile p l`, returns the longest prefix (possibly empty) of list `l` of elements that satisfy `p`
1860 """
1861 takeWhile :: (a -> <e> Boolean) -> [a] -> <e> [a]
1862 takeWhile f l = loop 0
1863   where
1864     len = length l
1865     loop i | i == len  = l
1866            | f (l!i)   = loop (i+1)
1867            | otherwise = take i l
1868
1869 partition :: (a -> <e> Boolean) -> [a] -> <e> ([a], [a])
1870 partition p l = runProc do
1871     res1 = newArrayList
1872     res2 = newArrayList
1873     for l (\el ->
1874         if p el
1875         then addArrayList res1 el
1876         else addArrayList res2 el
1877     )
1878     (Java.unsafeCoerce res1, Java.unsafeCoerce res2)
1879
1880 """
1881 `range begin end` produces a list of consecutive integers starting from `begin` and ending to `end` (including `end`).
1882 The compiler supports syntactic sugar `[begin..end]` for this function.
1883 """
1884 @inline
1885 range :: Integer -> Integer -> [Integer]
1886 range first last = build (\empty cons -> do
1887     loop i cur = if i > last then cur else loop (i+1) (cons cur i)
1888     loop first empty)
1889
1890 "A specific implementation of `iter` for lists."
1891 @inline
1892 iterList :: (a -> <e> b) -> [a] -> <e> ()
1893 iterList f l = foldl (\_ x -> ignore (f x)) () l
1894
1895 "A specific implementation of `iterI` for lists."
1896 @inline
1897 iterIList :: (Integer -> a -> <e> b) -> [a] -> <e> ()
1898 iterIList f l = do foldl (\i x -> do f i x ; i+1) 0 l ; ()
1899
1900 """
1901 Generates a list from a given starting state and iteration function.
1902 For example
1903
1904     let nextState 0 = Nothing
1905         nextState i = Just (i, i `div` 2)
1906     in  unfoldr nextState 30
1907
1908 produces
1909
1910     [30, 15, 7, 3, 1]
1911 """
1912 @inline
1913 unfoldr :: (b -> <e> Maybe (a, b)) -> b -> <e> [a]
1914 unfoldr f s = build (\empty cons -> do
1915     loop s cur =
1916         match f s with
1917             Just (el,newS) -> loop newS (cons cur el)
1918             _ -> cur
1919     loop s empty)
1920
1921 importJava "org.simantics.scl.runtime.Lists" where
1922     /*
1923     @private
1924     @JavaName map
1925     mapList :: (a -> b) -> [a] -> [b]
1926     @private
1927     @JavaName map
1928     mapEList :: (a -> <e> b) -> [a] -> <e> [b]
1929     @private
1930     @JavaName iter
1931     iterList :: (a -> <e> ()) -> [a] -> <e> ()
1932     concatMap :: (a -> <e> [b]) -> [a] -> <e> [b]
1933     */
1934     """
1935     Combines two lists into one list of pairs. The length of the resulting list is the length of the smallest input list.
1936
1937         zip [1, 2, 3, 4, 5] ['a', 'b', 'c'] = [(1, 'a'), (2, 'b'), (3, 'c')]
1938     """
1939     zip :: [a] -> [b] -> [(a,b)]
1940     "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."
1941     zipWith :: (a -> b -> <e> c) -> [a] -> [b] -> <e> [c]
1942     """
1943     Produces two lists from one list of pairs.
1944
1945         unzip [(1, 'a'), (2, 'b'), (3, 'c')] = ([1, 2, 3], ['a', 'b', 'c'])
1946     """
1947     unzip :: [(a,b)] -> ([a],[b])
1948
1949     //"@filter p l@ returns those elements of @l@ that the predicate @p@ accepts."
1950     //filter :: (a -> <e> Boolean) -> [a] -> <e> [a]
1951     //filterJust :: [Maybe a] -> [a]
1952     /*
1953     foldl :: (a -> b -> <e> a) -> a -> [b] -> <e> a
1954     */
1955     "Like `foldl` but assumes that the list is non-empty so the initial is not needed."
1956     foldl1 :: (a -> a -> <e> a) -> [a] -> <e> a
1957     //unfoldr :: (b -> <e> Maybe (a, b)) -> b -> <e> [a]
1958
1959     "Sorts the list using the given comparator."
1960     sortWith :: (a -> a -> <e> Integer) -> [a] -> <e> [a]
1961
1962     """
1963     Given a list of key-value pairs, the function produces a function that finds a value
1964     efficiently for the given key.
1965     """
1966     index :: [(a,b)] -> a -> Maybe b
1967
1968     """
1969     Given a list of values and a function computing a key for each value, the function produces a function that finds a value
1970     effeciently for the given key.
1971     """
1972     indexBy ::  (a -> <e> b) -> [a] -> <e> (b -> Maybe a)
1973
1974     "Works like `index` but uses the given functions as hash codes and equality."
1975     indexWith :: (a -> Integer) -> (a -> a -> Boolean) -> [(a,b)] -> a -> Maybe b
1976
1977     "Groups a list values by a key computed by the given function."
1978     groupBy :: (a -> <e> b) -> [a] -> <e> [(b, [a])]
1979
1980     "Groups a list of key-value pairs by the keys."
1981     group :: [(a,b)] -> [(a, [b])]
1982
1983     "Composition of index and groupBy."
1984     indexGroupBy :: (a -> <e> b) -> [a] -> <e> (b -> [a])
1985
1986     "Composition of index and group."
1987     indexGroup :: [(a,b)] -> a -> [b]
1988
1989     groupWith :: (b -> Integer) -> (b -> b -> Boolean) -> (a -> <e> b) -> (a -> <e> c) -> [a] -> <e> [(b, [c])]
1990
1991     "Removes duplicates (all but the first occurrence) from the list but otherwise preserves the order of the elements."
1992     unique :: [a] -> [a]
1993
1994     "Like `unique`, but uses the given function for finding the key values used for uniqueness testing."
1995     uniqueBy :: (a -> b) -> [a] -> [a]
1996
1997     "Works like `unique` but uses the given function for equality tests."
1998     uniqueWith :: (a -> a -> Boolean) -> [a] -> [a]
1999
2000     "Works like `\\\\` but uses the given function for equality tests."
2001     deleteAllBy :: (a -> a -> Boolean) -> [a] -> [a] -> [a]
2002
2003     @private
2004     listDifference :: [a] -> [a] -> [a]
2005
2006     //range :: Integer -> Integer -> [Integer]
2007
2008     //build :: (forall a. a -> (a -> b -> <e> a) -> <e> a) -> <e> [b]
2009
2010 "`elem el lst` return true, if `el` occurs in the list `lst`."
2011 elem :: a -> [a] -> Boolean
2012 elem el l = loop 0
2013   where
2014     len = length l
2015     loop i | i < len = if el == l!i
2016                        then True
2017                        else loop (i+1)
2018            | otherwise = False
2019
2020 "`elemMaybe v1 (Just v2)` returns true if `v1 == v2`. `elemMaybe v1 Nothing` is always false."
2021 elemMaybe :: a -> Maybe a -> Boolean
2022 elemMaybe el m = match m with
2023     Just el2 -> el == el2
2024     Nothing -> False
2025
2026 "`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."
2027 elemIndex :: a -> [a] -> Maybe Integer
2028 elemIndex el l = loop 0
2029   where
2030     len = length l
2031     loop i | i < len = if el == l!i
2032                        then Just i
2033                        else loop (i+1)
2034            | otherwise = Nothing
2035
2036 """
2037 Computes a list that contains only elements that belongs to both input lists.
2038 """
2039 intersect :: [a] -> [a] -> [a]
2040 intersect a b = filter f a
2041   where
2042     f e = elem e b
2043
2044 "Reverses a given list. For example, `reverse [1,2,3] = [3,2,1]`"
2045 reverse :: [a] -> [a]
2046 reverse l = [l!(len-i) | i <- [1..len]]
2047   where
2048     len = length l
2049
2050 """
2051 Transposes the rows and columns of its argument. For example,
2052
2053     transpose [[1,2,3],[4,5,6]] == [[1,4],[2,5],[3,6]]
2054     transpose [[1,2],[3,4,5]] == [[1,3],[2,4],[5]]
2055 """
2056 transpose xss = [[xs!i | xs <- xss, i < length xs]
2057                 | i <- [0..maximum [length xs | xs <- xss]-1]]
2058
2059 "Works like `unfoldr` but generates the list from right to left."
2060 unfoldl :: (b -> <e> Maybe (a, b)) -> b -> <e> [a]
2061 unfoldl f seed = reverse $ unfoldr f seed
2062
2063 "Removes the first element of the list, if the list is non-empty."
2064 tail :: [a] -> [a]
2065 tail l = if len < 2 then emptyList else subList l 1 len
2066   where
2067     len = length l
2068
2069 "Tries to find the given key from the list of key-value pairs and returns the corresponding value."
2070 lookup ::  a -> [(a, b)] -> Maybe b
2071 lookup el l = do
2072     len = length l
2073     loop i = if i < len
2074              then match l!i with
2075                (a,b) | a == el   -> Just b
2076                      | otherwise -> loop (i+1)
2077              else Nothing
2078     loop 0
2079
2080 "Conjunction over a list."
2081 @inline
2082 and :: [Boolean] -> Boolean
2083 and = foldl (&&) True
2084
2085 "Disjunction over a list."
2086 @inline
2087 or :: [Boolean] -> Boolean
2088 or  = foldl (||) False
2089
2090 """
2091 `any pred lst` tests whether the predicate `pred` holds some element of `lst`.
2092 It returns immediately when it encounters the first value satisfying the predicate.
2093 """
2094 any :: (a -> <e> Boolean) -> [a] -> <e> Boolean
2095 any p =  or . map p
2096
2097 """
2098 `all pred lst` tests whether the predicate `pred` holds for all elements of `lst`.
2099 It returns immediately when it encounters the first value not satisfying the predicate.
2100 """
2101 all :: (a -> <e> Boolean) -> [a] -> <e> Boolean
2102 all p =  and . map p
2103
2104 """
2105 Returns the first element of the list satisfying the given condition,
2106 or `Nothing` if there is no such element.
2107 """
2108 findFirst :: (a -> <e> Boolean) -> [a] -> <e> Maybe a
2109 findFirst p l = loop 0
2110   where
2111     len = length l
2112     loop i = if i < len
2113              then let el = l!i in
2114                   if p el
2115                   then Just el
2116                   else loop (i+1)
2117              else Nothing
2118     loop 0
2119
2120
2121 """
2122 Sorts the given list using its default order.
2123 """
2124 @inline
2125 sort :: Ord a => [a] -> [a]
2126 sort = sortWith compare
2127
2128 """
2129 Sorts the lists by the values computed by the first function.
2130 For example
2131
2132     sortBy snd [(1,5), (2,3), (3,4)] = [(2,3), (3,4), (1,5)]
2133 """
2134 @inline
2135 sortBy :: Ord b => (a -> <e> b) -> [a] -> <e> [a]
2136 sortBy f l = sortWith (\x y -> compare (f x) (f y)) l
2137 // This is faster if f is slow, but will generate more auxiliary structures
2138 //sortBy f l = map snd (sortWith (\(x,_) (y,_) -> compare x y) [(f x, x) | x <- l])
2139
2140 "`a \\\\ b` removes all elements of `b` from the list `a`."
2141 (\\) :: [a] -> [a] -> [a]
2142 (\\) = listDifference
2143
2144 /// Dynamic ///
2145
2146 importJava "java.lang.Object" where
2147     "A data type that can represent any value."
2148     data Dynamic
2149
2150     @private
2151     @JavaName toString
2152     showDynamic :: Dynamic -> String
2153
2154 instance Show Dynamic where
2155     show = showDynamic
2156
2157 "Converts a value to `Dynamic` type."
2158 toDynamic :: a -> Dynamic
2159 toDynamic = Java.unsafeCoerce
2160
2161 "Converts a `Dynamic` value to a required value, or fails if the conversion is not possible."
2162 importJava "org.simantics.scl.compiler.runtime.ValueConversion" where
2163     fromDynamic :: Typeable a => Dynamic -> a
2164
2165 /// Procedures ///
2166
2167 importJava "org.simantics.scl.runtime.procedure.Ref" where
2168     "A mutable reference to a value of type `a`."
2169     data Ref a
2170
2171     "Creates a new reference with the given initial value."
2172     @JavaName "<init>"
2173     ref :: a -> <Proc> (Ref a)
2174
2175     "Returns the current value of the reference."
2176     @JavaName "value"
2177     getRef :: Ref a -> <Proc> a
2178
2179     "Sets a new value for the reference."
2180     @JavaName "<set>value"
2181     (:=) :: Ref a -> a -> <Proc> ()
2182
2183 instance Show (Ref a) where
2184     show _ = "<reference>"
2185
2186 importJava "org.simantics.scl.runtime.reporting.SCLReporting" where
2187     "Prints the given string to the console."
2188     @JavaName "print"
2189     printString :: String -> <Proc> ()
2190     "Prints an error message to the console."
2191     printError :: String -> <Proc> ()
2192     "Reports that certain amount of work has been done for the current task."
2193     didWork :: Double -> <Proc> ()
2194     """
2195     `printingToFile "fileName" expression` executes the `expression` so that all its console prints
2196     are written to the file given as a first parameter.
2197     """
2198     printingToFile :: String -> (<e> a) -> <e> a
2199     """
2200     `printErrorsAsNormalPrints expression` executes the `expression` so that all its error prints
2201     are printed as normal prints. This is useful mainly in testing scripts for checking that the implementations
2202     give proper error messages with invalid inputs.
2203     """
2204     printErrorsAsNormalPrints :: (<e> a) -> <e> a
2205     """
2206     `disablePrintingForCommand expression` executes the `expression` so that it does not print return values.
2207     Errors are printed normally.
2208     """
2209     disablePrintingForCommand :: (<e> a) -> <e> a
2210
2211
2212 importJava "org.simantics.scl.runtime.procedure.Procedures" where
2213     "Returns `True` if the current thread has been interrupted."
2214     isInterrupted :: <Proc> Boolean
2215     "Checks whether the current thread has been interrupted and throws an exception if it is."
2216     checkInterrupted :: <Proc> ()
2217     "Generates a random identifier."
2218     generateUID :: <Proc> String
2219
2220     "Executes the given expression and catches certain class of exceptions (specified by the catch handler that is given as a second parameter.)"
2221     @JavaName catch_
2222     catch :: VecComp ex => (<e,Exception> a) -> (ex -> <e> a) -> <e> a
2223
2224 importJava "java.lang.Throwable" where
2225     data Throwable
2226     @private
2227     @JavaName toString
2228     showThrowable :: Throwable -> String
2229     @private
2230     @JavaName getMessage
2231     getMessageThrowable :: Throwable -> String
2232     @private
2233     @JavaName getCause
2234     getCauseThrowable :: Throwable -> Maybe Throwable
2235 importJava "java.lang.Exception" where
2236     data Exception
2237     @private
2238     @JavaName toString
2239     showException :: Exception -> String
2240
2241 instance Show Throwable where
2242     show = showThrowable
2243 instance Show Exception where
2244     show = showException
2245
2246 class Throwable e where
2247     toThrowable :: e -> Throwable
2248
2249 messageOfException :: Throwable e => e -> String
2250 messageOfException = getMessageThrowable . toThrowable
2251
2252 causeOfException :: Throwable e => e -> Maybe Throwable
2253 causeOfException = getCauseThrowable . toThrowable
2254
2255 instance Throwable Throwable where
2256     toThrowable = id
2257 instance Throwable Exception where
2258     toThrowable = Java.unsafeCoerce
2259
2260 "Prints the given value in the console."
2261 @inline
2262 print :: Show a => a -> <Proc> ()
2263 print v = printString (showForPrinting v)
2264 /*
2265 instance Show TypeRep where
2266     sb <+ (TApply (TCon "Builtin" "[]") b) =
2267         sb << "[" <+ b << "]"
2268     sb <+ (TApply (TApply (TCon "Builtin" "(,)") c1) c2) =
2269         sb << "(" <+ c1 << "," <+ c2 << ")"
2270     sb <+ (TApply (TApply (TApply (TCon "Builtin" "(,,)") c1) c2) c3) =
2271         sb << "(" <+ c1 << "," <+ c2 << "," <+ c3 << ")"
2272     sb <+ (TApply (TApply (TApply (TApply (TCon "Builtin" "(,,,)") c1) c2) c3) c4) =
2273         sb << "(" <+ c1 << "," <+ c2 << "," <+ c3 << "," <+ c4 << ")"
2274
2275     sb <+ (TCon _ name) = sb << name
2276     sb <+ (TApply a b) = sb <+ Par 1 a << " " <+ Par 2 b
2277     sb <+ (TFun a b) = sb <+ Par 1 a << " -> " <+ b
2278
2279     precedence (TCon _ _) = 0
2280     precedence (TFun _ _) = 2
2281     precedence (TApply a _) = if isSpecialType a then 0 else 1
2282       where
2283         isSpecialType (TCon "Builtin" "[]") = True
2284         isSpecialType (TCon "Builtin" "()") = True
2285         isSpecialType (TCon "Builtin" "(,)") = True
2286         isSpecialType (TCon "Builtin" "(,,)") = True
2287         isSpecialType (TCon "Builtin" "(,,,)") = True
2288         isSpecialType (TApply a _) = isSpecialType a
2289 */
2290
2291 // Type
2292
2293 @private
2294 importJava "org.simantics.scl.compiler.types.Type" where
2295     @JavaName toString
2296     showType :: Type -> String
2297
2298 importJava "org.simantics.scl.compiler.types.Types" where
2299     removeForAll :: Type -> Type
2300
2301 instance Show Type where
2302     show = showType