1 import "JavaBuiltin" as Java
2 import "StringBuilder" as StringBuilder
4 /** The following types and names are builtin *************
5 data Boolean = True | False
24 data [a] = [] | [a] | [a,a] | [a,a,a] | ...
27 data (a,b,c) = (a,b,c)
28 data Maybe a = Nothing | Just a
32 data TypeRep = TCon String | TApply TypeRep TypeRep
34 typeOf :: Typeable a => a -> Type
38 binding :: Serializable a => Binding a
39 ***********************************************************/
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
50 importJava "java.util.Arrays" where
53 showDoubleArray :: DoubleArray -> String
55 "Converts an array to a list."
57 arrayToList :: Array a -> [a]
59 importJava "java.util.List" where
60 "Converts a list to an array."
62 listToArray :: [a] -> Array a
64 instance Show DoubleArray where
65 show = showDoubleArray
67 importJava "org.simantics.scl.runtime.Coercion" where
68 "Converts a list of doubles to a double array."
69 toDoubleArray :: [Double] -> DoubleArray
70 "Converts a double array to a list of doubles."
71 fromDoubleArray :: DoubleArray -> [Double]
74 * Precedences and associativity of all operators defined in Prelude
80 infixl 7 (*), (/), div, mod
82 infixl 5 (\\), (<<), (<+)
83 infix 4 (!=), (<), (<=), (>=), (>)
85 infixr 2 (||), orElse, morelse
86 infixr 1 (>>=), (>>), (:=), (>=>)
90 "Creates a constant function. `const x` defines a function that always returns `x`."
96 Function application. `f $ x` is equivalent with `f x`. The function has two uses.
97 First is to remove parentheses from deeply nested expressions:
99 f (g (h x)) == f $ g $ h x
101 The second use is with higher order functions:
103 map ($ parameter) functions
107 ($) :: (a -> <e> b) -> a -> <e> b
110 "Transforms a function taking a pair as a parameter to a function taking two values as a parameter."
112 curry :: ((a, b) -> <e> c) -> a -> b -> <e> c
113 curry f x y = f (x, y)
115 "Transforms a function two values as a parameter to a function taking a pair as a parameter."
117 uncurry :: (a -> b -> <e> c) -> ((a, b) -> <e> c)
118 uncurry f (x, y) = f x y
120 "Transforms a function taking a triple as a parameter to a function taking three values as a parameter."
122 curry3 :: ((a, b, c) -> <e> d) -> a -> b -> c -> <e> d
123 curry3 f x y z = f (x, y, z)
125 "Transforms a function three values as a parameter to a function taking a priple as a parameter."
127 uncurry3 :: (a -> b -> c -> <e> d) -> ((a, b, c) -> <e> d)
128 uncurry3 f (x, y, z) = f x y z
130 "Flips the parameters of a binary function."
132 flip :: (a -> b -> <e> c) -> b -> a -> <e> c
135 "Swaps the order of elements of a pair (2-tuple)."
136 swap :: (a,b) -> (b,a)
142 (!=) :: a -> a -> Boolean
143 a != b = not (a == b)
146 The class of linearly ordered types.
147 Method `compare` must be implemented in instances.
151 `compare x y` returns a negative number, if `x` is smaller than `y`,
152 a positive number, if `x` is bigger than `y` and zero if they are equal.
154 compare :: a -> a -> Integer
155 compare a b = if a < b then -1 else if a > b then 1 else 0
158 (<) :: a -> a -> Boolean
159 a < b = compare a b < 0
161 (<=) :: a -> a -> Boolean
162 a <= b = compare a b <= 0
164 (>) :: a -> a -> Boolean
165 a > b = compare a b > 0
167 (>=) :: a -> a -> Boolean
168 a >= b = compare a b >= 0
170 "Minimum of the parameters"
172 min a b = if a < b then a else b
173 "Maximum of the parameters"
175 max a b = if a > b then a else b
178 Combines two integers such that if the first one is non-zero, it is returned, otherwise
179 the second-one. The second parameter is not implemented, if it is not needed.
181 The function is useful for implementing efficient recursive comparison of structures,
184 compare (x1,y1,z1) (x2,y2,z2) = compare x1 x2 &<& compare y1 y2 &<& compare z1 z2
187 (&<&) :: Integer -> (<e> Integer) -> <e> Integer
188 a &<& b = if a == 0 then b else a
190 "Maximum over a list"
192 maximum :: Ord a => [a] -> a
195 "Minimum over a list"
197 minimum :: Ord a => [a] -> a
200 "As `maximum` but compares the elements by the given projection."
201 maximumBy :: Ord b => (a -> <e> b) -> [a] -> <e> a
202 maximumBy f l = snd $ foldl1 maxF $ map (\x -> (f x, x)) l
204 maxF a b = if fst a >= fst b then a else b
207 As `minimum` but compares the elements by the given projection.
212 returns a pair with the smallest second component.
214 minimumBy :: Ord b => (a -> <e> b) -> [a] -> <e> a
215 minimumBy f l = snd $ foldl1 minF $ map (\x -> (f x, x)) l
217 minF a b = if fst a <= fst b then a else b
221 instance Functor ((->) a) where
224 instance Monad ((->) a) where
226 (m >>= f) x = f (m x) x
229 instance Category (->) where
234 instance (Additive b) => Additive (a -> <e> b) where
236 (f + g) x = f x + g x
238 instance (Ring b) => Ring (a -> <e> b) where
240 (neg f) x = neg (f x)
241 (f - g) x = f x - g x
242 (f * g) x = f x * g x
243 (fromInteger c) x = fromInteger c
245 //instance Show (a -> <e> b) where
246 // show f = "<function>"
248 "Appends a string to the string builder."
249 (<<) :: StringBuilder.T -> String -> <Proc> StringBuilder.T
250 (<<) = StringBuilder.appendString
253 The class of types whose elements can be converted to a string representation.
254 Method `show` or `(<+)` must be implemented.
257 "Converts a value to string."
259 "Appends the string representation of the value to the string builder."
260 (<+) :: StringBuilder.T -> a -> <Proc> StringBuilder.T
262 Returns the precedence of the value. It is used to determine if parenteheses
263 are needed around the string representation of the value. The default value is 0
264 and means that parentheses are never added.
266 precedence :: a -> Integer
268 "Converts a value to a string like `show` but does not put string literals in double quotes."
269 showForPrinting :: a -> String
271 show v = runProc (StringBuilder.toString (StringBuilder.new <+ v))
272 showForPrinting v = show v
273 sb <+ v = StringBuilder.appendString sb (show v)
277 `Par` data type is used to control the placement of parentheses when converting values to string.
278 Value `Par prec val` is converted to string like `val` but parentheses are put around, if the
279 precedence of the value is greater than `prec`.
281 data Par a = Par Integer a
283 instance (Show a) => Show (Par a) where
284 sb <+ (Par outerPrec v) = if prec > outerPrec
285 then sb << "(" <+ v << ")"
287 where prec = precedence v
289 "Type class for parsing strings to values."
291 "Converts a string to a required type of value."
294 The `Additive` class is used for types that are additive monoids. The operations
295 must satisfy the following laws (at least approximately, when implemented for
296 floating point numbers):
297 (a + b) + c = a + (b + c)
300 class Additive a where
302 Neutral element of (+), i.e,
308 "Adds two objects (numbers, vectors, strings, etc.) together."
313 sum [e1,e2,...,eN] = e1 + e2 + ... + eN
315 Implemented usually more efficiently than with repetitive
316 application of `(+)`.
321 class (Additive a) => AdditiveGroup a where
327 The `Ring` class is used for types that are algebraic rings. The operations
328 must satisfy the following laws (at least approximately)
329 in addition to the laws of Additive:
334 (a * b) * c = a * (b * c)
336 a * (b + c) = a * b + a * c
337 (a + b) * c = a * c + b * c
339 class (Additive a) => Ring a where
341 Negation. Synonym for unary `-`.
346 "Neutral element of multiplication"
350 "Converts an integer to a desired numeric type."
351 fromInteger :: Integer -> a
356 The `OrderedRing` class combines the Ring and Ord classes. It additionally
357 supports absolute value function.
359 class (Ring a, Ord a) => OrderedRing a where
362 abs x = if x < zero then neg x else x
363 "Converts the given number to `Integer`"
364 toInteger :: a -> Integer
367 The `Integer` class is used for types that represent either all integers or some
370 class (OrderedRing a) => Integral a where
371 "Integer division truncated toward zero."
373 "Integer remainder, satisfying ``(x `div` y)*y + (x `mod` y) = x``"
377 The `Real` class is used for types that represent some approximation of real numbers.
379 class (OrderedRing a) => Real a where
384 "Pi (3.141592654...)"
410 "Inverse hyberbolic sine"
412 "Inverse hyberbolic cosine"
414 "Inverse hyberbolic tangent"
416 "The largest integer not greater than the given number"
418 "The smallest integer not smaller than the given number"
422 Two parameter version of `atan`. Its value is determined by the following
423 equations when (x,y) is a unit vector:
430 atan2 y x = atan (y/x)
433 "Converts a `Double` value to a desired numeric type."
434 fromDouble :: Double -> a
435 "Converts the given number to `Double`"
436 toDouble :: a -> Double
438 a ^ b = exp (b * log a)
440 sinh x = 0.5 * (exp x - exp (neg x))
441 cosh x = 0.5 * (exp x + exp (neg x))
442 tanh x = (e2x - 1) / (e2x + 1)
446 asinh x = log (x + sqrt (x*x + one))
447 acosh x = log (x + sqrt (x*x - one))
448 atanh x = 0.5 * log ((one+x)/(one-x))
450 /// Import mathematical functions ///
453 importJava "java.lang.Math" where
458 sinDouble :: Double -> Double
461 cosDouble :: Double -> Double
464 tanDouble :: Double -> Double
467 asinDouble :: Double -> Double
470 acosDouble :: Double -> Double
473 atanDouble :: Double -> Double
476 atan2Double :: Double -> Double -> Double
479 sinhDouble :: Double -> Double
482 coshDouble :: Double -> Double
485 tanhDouble :: Double -> Double
488 expDouble :: Double -> Double
491 logDouble :: Double -> Double
494 powDouble :: Double -> Double -> Double
497 sqrtDouble :: Double -> Double
500 ceilDouble :: Double -> Double
503 floorDouble :: Double -> Double
506 roundDouble :: Double -> Long
509 absInteger :: Integer -> Integer
512 absLong :: Long -> Long
515 absFloat :: Float -> Float
518 absDouble :: Double -> Double
521 minInteger :: Integer -> Integer -> Integer
524 minLong :: Long -> Long -> Long
527 minFloat :: Float -> Float -> Float
530 minDouble :: Double -> Double -> Double
533 maxInteger :: Integer -> Integer -> Integer
536 maxLong :: Long -> Long -> Long
539 maxFloat :: Float -> Float -> Float
542 maxDouble :: Double -> Double -> Double
547 importJava "java.lang.Byte" where
549 showByte :: Byte -> String
552 readByte :: String -> Byte
554 instance Ord Byte where
560 instance Additive Byte where
561 zero = Java.i2b Java.iconst_0
564 instance Ring Byte where
567 one = Java.i2b Java.iconst_1
569 fromInteger = Java.i2b
571 instance Show Byte where
573 precedence v = if v >= 0 then 0 else 100
575 instance Read Byte where
580 importJava "java.lang.Short" where
582 showShort :: Short -> String
585 readShort :: String -> Short
587 instance Ord Short where
593 instance Additive Short where
597 instance Ring Short where
602 fromInteger = Java.i2s
604 instance Show Short where
606 precedence v = if v >= 0 then 0 else 100
608 instance Read Short where
614 importJava "java.lang.Integer" where
616 showInteger :: Integer -> String
619 readInteger :: String -> Integer
621 instance Ord Integer where
627 instance Additive Integer where
631 instance Ring Integer where
638 instance OrderedRing Integer where
642 instance Integral Integer where
646 instance Show Integer where
648 precedence v = if v >= 0 then 0 else 100
650 instance Read Integer where
656 importJava "java.lang.Long" where
658 showLong :: Long -> String
661 readLong :: String -> Long
663 instance Ord Long where
669 instance Additive Long where
673 instance Ring Long where
678 fromInteger = Java.i2l
680 instance OrderedRing Long where
684 instance Integral Long where
688 instance Show Long where
690 precedence v = if v >= 0 then 0 else 100
692 instance Read Long where
697 importJava "java.lang.Float" where
700 compareFloat :: Float -> Float -> Integer
704 showFloat :: Float -> String
708 readFloat :: String -> Float
710 "Converts 32-bit floating point number to a 32-bit integer with the same byte level representation."
711 floatToIntBits :: Float -> Integer
713 instance Ord Float where
714 compare = compareFloat
720 instance Additive Float where
724 instance Ring Float where
729 fromInteger = Java.i2f
731 instance OrderedRing Float where
735 instance Real Float where
737 x ^ y = Java.d2f (powDouble (Java.f2d x) (Java.f2d y))
738 pi = fromDouble piDouble
739 sqrt = Java.d2f . sqrtDouble . Java.f2d
740 exp = Java.d2f . expDouble . Java.f2d
741 log = Java.d2f . logDouble . Java.f2d
742 sin = Java.d2f . sinDouble . Java.f2d
743 cos = Java.d2f . cosDouble . Java.f2d
744 tan = Java.d2f . tanDouble . Java.f2d
745 asin = Java.d2f . asinDouble . Java.f2d
746 acos = Java.d2f . acosDouble . Java.f2d
747 atan = Java.d2f . atanDouble . Java.f2d
748 sinh = Java.d2f . sinhDouble . Java.f2d
749 cosh = Java.d2f . coshDouble . Java.f2d
750 tanh = Java.d2f . tanhDouble . Java.f2d
751 floor = Java.d2f . floorDouble . Java.f2d
752 ceil = Java.d2f . ceilDouble . Java.f2d
753 atan2 y x = Java.d2f (atan2Double (Java.f2d y) (Java.f2d x))
754 round = roundDouble . Java.f2d
755 fromDouble = Java.d2f
758 instance Show Float where
760 precedence v = if v >= 0 then 0 else 100
762 instance Read Float where
767 importJava "java.lang.Double" where
770 compareDouble :: Double -> Double -> Integer
774 showDouble :: Double -> String
777 @JavaName parseDouble
778 readDouble :: String -> Double
780 "Converts 64-bit floating point number to a 64-bit integer with the same byte level representation."
781 doubleToLongBits :: Double -> Long
783 isFinite :: Double -> Boolean
784 isNaN :: Double -> Boolean
785 isInfinite :: Double -> Boolean
787 instance Ord Double where
788 compare = compareDouble
794 instance Additive Double where
798 instance Ring Double where
803 fromInteger = Java.i2d
805 instance OrderedRing Double where
809 instance Real Double where
832 instance Show Double where
834 precedence v = if v >= 0 then 0 else 100
836 instance Read Double where
841 importJava "java.lang.Character" where
843 showCharacter :: Character -> String
845 "Returns true, if the given character is a letter."
846 isLetter :: Character -> Boolean
848 "Returns true, if the given character is a digit."
849 isDigit :: Character -> Boolean
851 instance Ord Character where
857 instance Show Character where
858 sb <+ c = sb << "'" << showCharacter c << "'"
860 "Adds a given integer to the character code."
861 addChar :: Character -> Integer -> Character
864 "Subtracts a given integer from the character code."
865 subChar :: Character -> Character -> Integer
871 The `Functor` class is used for types that can be mapped over. Instances of `Functor` should satisfy the following laws:
874 fmap (f . g) == fmap f . fmap g
876 class Functor f where
877 "Lifts a pure function to the given functor."
878 fmap :: (a -> b) -> f a -> f b
880 class CoFunctor f where
881 comap :: (a -> b) -> f b -> f a
885 class (Functor f) => Applicative f where
887 (<*>) :: f (a -> b) -> f a -> f b
888 (*>) :: f a -> f b -> f b
889 (<*) :: f a -> f b -> f a
891 u *> v = pure (const id) <*> u <*> v
892 u <* v = pure const <*> u <*> v
893 fmap f x = pure f <*> x
898 The `Monad` class defines the basic operations over a monad, a concept from a branch of mathematics known as category theory.
899 From the perspective of a SCL programmer, however, it is best to think of a monad as an abstract datatype of actions.
900 SCL's `mdo expressions provide a convenient syntax for writing monadic expressions.
902 Instances of `Monad` should satisfy the following laws:
904 return a >>= k == k a
906 m >>= (\x -> k x >>= h) == (m >>= k) >>= h
907 fmap f xs == xs >>= return . f
909 class (Functor m) => Monad m where
910 "Inject a value into the monadic type."
912 "Sequentially compose two actions, passing any value produced by the first as an argument to the second."
913 (>>=) :: m a -> (a -> m b) -> m b
915 The join function is the conventional monad join operator. It removes one level of monadic
918 For lists, `join` concatenates a list of lists:
920 join [[1,2], [3,4]] = [1, 2, 3, 4]
922 join :: m (m a) -> m a
926 Sequentially compose two actions, discarding any value produced by the first, like sequencing operators
927 (such as the semicolon) in imperative languages."
930 (>>) :: Monad m => m a -> m b -> m b
931 a >> b = a >>= (\_ -> b)
933 "Left-to-right Kleisli composition of monads."
934 (>=>) :: Monad m => (a -> m b) -> (b -> m c) -> (a -> m c)
935 (f >=> g) x = (f x) >>= g
937 "While loop. `while cond body` executes the `body` while the `cond` is true."
939 while :: (<e> Boolean) -> (<e> a) -> <e> ()
940 while cond body = loop ()
941 where loop _ = if cond
942 then do body ; loop ()
946 Sequences the given monadic value infinitely:
948 repeatForever m = m >> m >> m >> ...
950 repeatForever m = m >> repeatForever m
952 replicateM :: Monad m => Integer -> m a -> m [a]
953 replicateM count m = loop count emptyList
955 loop count l | count <= 0 = return l
958 loop (count-1) (addList l v)
960 replicateM_ :: Monad m => Integer -> m a -> m ()
961 replicateM_ count m | count <= 0 = return ()
962 | otherwise = m >> replicateM_ (count-1) m
967 A class of monads with zero element satisfying
971 class (Monad m) => MonadZero m where
974 "Injects a boolean test to a type beloning to `MonadZero`."
975 guard :: MonadZero m => Boolean -> m ()
976 guard True = return ()
982 A class of monads with associative binary operator `mplus` satisfying the following laws:
986 mplus (mplus a b) c = mplus a (mplus b c)
987 mplus a b >>= k = mplus (a >>= k) (b >>= k)
989 class (MonadZero m) => MonadPlus m where
990 mplus :: m a -> m a -> m a
995 A class of monads with associative binary operator `morelse` satisfying the following laws:
999 morelse (morelse a b) c = morelse a (morelse b c)
1000 morelse (return a) b = return a
1002 class (MonadZero m) => MonadOr m where
1003 morelse :: m a -> m a -> m a
1008 A class of types that can be mapped over with effectful mapping functions.
1010 class (Functor f) => FunctorE f where
1012 Applies the function to all elements of the container and
1013 returns the similarly shaped container with the results:
1017 map f [e1, e2, ..., eN] = [f e1, f e2, ..., f eN]
1021 map (*2) [1..5] = [2, 4, 6, 8, 10]
1023 map :: (a -> <e> b) -> f a -> <e> (f b)
1024 "Calls the given function with all elements of the given container."
1025 iter :: (a -> <e> b) -> f a -> <e> ()
1026 "Calls the given function with all elements of the given container giving also the index of the element as a parameter."
1027 iterI :: (Integer -> a -> <e> b) -> f a -> <e> ()
1029 "Iterates the elements of the given collection. Same as `iter` but parameters flipped."
1030 for :: FunctorE f => f a -> (a -> <e> b) -> <e> ()
1034 "Iterates the elements of the given collection providing also the indices of the elements. Same as `iterI` but parameters flipped."
1035 forI :: FunctorE f => f a -> (Integer -> a -> <e> b) -> <e> ()
1037 forI l f = iterI f l
1039 "`forN n f` calls `f` for all integers `0`, ..., `n-1`"
1041 forN :: Integer -> (Integer -> <e> b) -> <e> ()
1045 then do f i ; loop (i+1)
1049 mapI :: (Integer -> a -> <e> b) -> [a] -> <e> [b]
1050 mapI f l = build (\empty cons -> let
1052 loop i accum = if i < len
1053 then loop (i+1) (cons accum (f i (l!i)))
1058 `mapMaybe` combines `map` and `filter` functions.
1059 It applies the given function to every element of the input list. If the result
1060 is `Just x`, then `x` is added to the resulting list.
1062 mapMaybe f lst = [y | x <- lst, Just y = f x]
1065 mapMaybe :: (a -> <e> Maybe b) -> [a] -> <e> [b]
1066 mapMaybe f l = build (\empty cons -> foldl (\cur x -> match f x with Just v -> cons cur v ; _ -> cur) empty l)
1069 Applies the given function to all elements of the list. Produces two lists: the first contains all elements `x`
1070 for which the function returned `Left x` and the second list contains all elements `y` for which the function
1073 mapEither :: (a -> <e> Either b c) -> [a] -> <e> ([b], [c])
1074 mapEither f list = runProc do
1077 for list (\x -> match f x with
1078 Left v -> addArrayList l v
1079 Right v -> addArrayList r v)
1080 (Java.unsafeCoerce l, Java.unsafeCoerce r)
1082 "`replicate n v` returns a list of length `n` such that each element is a copy of `v`."
1084 replicate :: Integer -> a -> [a]
1085 replicate n v = build (\empty cons ->
1087 aux i l = aux (i-1) (cons l v)
1093 class (FunctorE f) => FunctorM f where
1094 "`mapM f` is equivalent to `sequence . map f`."
1095 mapM :: Monad m => (a -> <e> m b) -> f a -> <e> m (f b)
1096 "Evaluate each action in the sequence from left to right, and collect the results."
1097 sequence :: Monad m => f (m a) -> m (f a)
1098 mapM f l = sequence (map f l)
1102 class (FunctorE m, Monad m) => MonadE m where
1103 bindE :: m a -> (a -> <e> m b) -> <e> m b
1105 instance MonadE Maybe where
1106 bindE Nothing _ = Nothing
1107 bindE (Just v) f = f v
1109 instance MonadE (Either a) where
1110 bindE (Left v) _ = Left v
1111 bindE (Right v) f = f v
1113 instance MonadE [] where
1114 bindE l f = concatMap f l
1118 "Identity function."
1123 Ignores the given value. This function is used in a situation where a function returns
1124 a value in a context where the value is not expected.
1131 ignoreM :: a -> Maybe b
1135 Composes two functions
1138 (.) :: (b -> <e> c) -> (a -> <e> b) -> (a -> <e> c)
1143 "A type class for sequences. All sequences must support indexing by integers."
1144 class /*(Additive a) =>*/ Sequence a where
1145 "Length of the sequence"
1146 length :: a -> Integer
1147 "`take n s` returns the first `n` elements of the sequence `s`."
1148 take :: Integer -> a -> a
1149 "`drop n s` removes the first `n` elements of the sequence `s`."
1150 drop :: Integer -> a -> a
1152 `sub s begin end` returns a subsequence of `s` starting from
1153 index `begin` and ending just before index `end`.
1155 sub :: a -> Integer -> Integer -> a
1157 take n v = sub v 0 (min n (length v))
1158 drop n v = sub v (min n len) len
1162 instance Sequence [a] where
1166 instance Sequence String where
1167 length = lengthString
1170 class IndexedSequence f where
1171 "`seq ! i` returns the `i`th element of the sequence `seq`. Indexing starts from zero."
1172 (!) :: f a -> Integer -> a
1174 "Returns the first element of a sequence"
1178 "Returns the last element of a sequence"
1180 last l = l!(length l-1)
1182 instance IndexedSequence [] where
1188 Equivalent to the boolean value `True`. The value is meant to be used in
1195 otherwise :: Boolean
1198 instance Ord Boolean where
1199 compare False False = 0
1200 compare False True = neg 1
1201 compare True False = 1
1202 compare True True = 0
1204 instance Show Boolean where
1206 show False = "False"
1209 Boolean conjunction (and). The function is a macro that evaluates the second parameter
1210 only if the first parameter is `True`.
1213 <tr><th>a</th><th>b</th><th>a && b</th></tr>
1214 <tr><td>True</td><td>True</td><td>True</td></tr>
1215 <tr><td>True</td><td>False</td><td>False</td></tr>
1216 <tr><td>False</td><td>not evaluated</td><td>False</td></tr>
1220 (&&) :: Boolean -> Boolean -> Boolean
1221 a && b = if a then b else False
1224 Boolean disjunction (or). The function is a macro that evaluates the second parameter
1225 only if the first parameter is `False`.
1228 <tr><th>a</th><th>b</th><th>a || b</th></tr>
1229 <tr><td>True</td><td>not evaluated</td><td>True</td></tr>
1230 <tr><td>False</td><td>True</td><td>True</td></tr>
1231 <tr><td>False</td><td>False</td><td>False</td></tr>
1235 (||) :: Boolean -> Boolean -> Boolean
1236 a || b = if a then True else b
1240 not a = if a then False else True
1244 //data Maybe a = Nothing | Just a
1246 "Given `Just x` this function returns `x`. If the parameter is `Nothing`, the function raises an exception."
1247 fromJust :: Maybe a -> a
1248 fromJust (Just a) = a
1250 deriving instance (Ord a) => Ord (Maybe a)
1251 deriving instance (Show a) => Show (Maybe a)
1253 instance Functor Maybe where
1254 fmap _ Nothing = Nothing
1255 fmap f (Just x) = Just (f x)
1257 instance FunctorE Maybe where
1258 map _ Nothing = Nothing
1259 map f (Just x) = Just (f x)
1262 iter f (Just x) = ignore (f x)
1264 iterI _ Nothing = ()
1265 iterI f (Just x) = ignore (f 0 x)
1267 instance Monad Maybe where
1271 Nothing >>= _ = Nothing
1275 join Nothing = Nothing
1278 instance MonadZero Maybe where
1281 instance MonadOr Maybe where
1282 morelse a@(Just _) _ = a
1285 "`execJust v f` executes the function `f` with parameter value `x`, if `v=Just x`. If `v=Nothing`, the function does nothing."
1287 execJust :: Maybe a -> (a -> <e> b) -> <e> ()
1288 execJust maybeValue procedure = match maybeValue with
1289 Just v -> ignore $ procedure v
1292 "`fromMaybe def v` returns `def` if `v=Nothing` and `x` if `v=Just x`."
1294 fromMaybe :: a -> Maybe a -> a
1295 fromMaybe default maybeValue = match maybeValue with
1301 Provides a default value if the first parameter is Nothing.
1302 The default value is evaluated only if needed. The function
1303 can be used as an operator and is right associative so that
1304 the following is possible:
1306 tryWithTheFirstMethod
1307 `orElse` tryWithTheSecondMethod
1308 `orElse` fail "Didn't succeed."
1311 orElse :: Maybe a -> (<e> a) -> <e> a
1312 orElse (Just x) _ = x
1313 orElse Nothing def = def
1318 The Either type represents values with two possibilities: a value of type `Either a b` is either `Left a` or `Right b`.
1320 The `Either` type is sometimes used to represent a value which is either correct or an error; by convention, the `Left` constructor
1321 is used to hold an error value and the `Right` constructor is used to hold a correct value (mnemonic: "right" also means "correct").
1323 @JavaType "org.simantics.scl.runtime.either.Either"
1325 @JavaType "org.simantics.scl.runtime.either.Left"
1328 | @JavaType "org.simantics.scl.runtime.either.Right"
1332 deriving instance (Ord a, Ord b) => Ord (Either a b)
1333 deriving instance (Show a, Show b) => Show (Either a b)
1335 instance Functor (Either a) where
1336 fmap _ (Left x) = Left x
1337 fmap f (Right y) = Right (f y)
1339 instance FunctorE (Either a) where
1340 map _ (Left x) = Left x
1341 map f (Right y) = Right (f y)
1343 iter _ (Left x) = ()
1344 iter f (Right y) = ignore (f y)
1346 iterI _ (Left x) = ()
1347 iterI f (Right y) = ignore (f 0 y)
1349 instance Monad (Either b) where
1352 Left x >>= _ = Left x
1355 join (Left x) = Left x
1360 importJava "java.lang.String" where
1363 concatString :: String -> String -> String
1365 @JavaName "compareTo"
1366 compareString :: String -> String -> Integer
1369 lengthString :: String -> Integer
1372 `replaceString original pattern replacement` replaces all occurrences of `pattern` in the string by `replacement`.
1375 replaceString :: String -> String -> String -> String
1379 splitString_ :: String -> String -> Array String
1382 `indexOf string s` finds the first occurrence of `s` from `string` and returns its index.
1383 If the `s` does not occur in the string, return `-1`."
1386 indexOf :: String -> String -> Integer
1388 "Works like `indexOf` but starts searching from the given index instead of the beginning of the string."
1390 indexOfStartingFrom :: String -> String -> Integer -> Integer
1392 "Works like `indexOf` but returns the index of the last occurrence."
1393 @JavaName lastIndexOf
1394 lastIndexOf :: String -> String -> Integer
1396 "Works like `lastIndexOf` but starts searching from the given index instead of the end of the string."
1397 @JavaName lastIndexOf
1398 lastIndexOfStartingFrom :: String -> String -> Integer -> Integer
1402 subString :: String -> Integer -> Integer -> String
1405 `regionMatches str1 offset1 str2 offset2 len` tests whether
1406 `sub str1 offset1 (offset1+len) == sub str2 offset2 (offset2+len)`.
1408 regionMatches :: String -> Integer -> String -> Integer -> Integer -> Boolean
1410 "`startsWith string prefix` returns true if the string begins with the given prefix."
1411 startsWith :: String -> String -> Boolean
1413 "`endsWith string suffix` returns true if the string ends with the given prefix."
1414 endsWith :: String -> String -> Boolean
1416 "Removes leading and trailing whitespace from the string."
1417 trim :: String -> String
1419 "`contains string s` returns true if `string` contains `s` as a substring."
1420 contains :: String -> String -> Boolean
1422 "`charAt string i` returns the `i`th character of the string."
1423 charAt :: String -> Integer -> Character
1425 "Converts all letters of the string to lower case."
1426 toLowerCase :: String -> String
1427 "Converts all letters of the string to upper case."
1428 toUpperCase :: String -> String
1430 "Creates a string from a vector of characters."
1432 string :: Vector Character -> String
1434 getBytes :: String -> String -> ByteArray
1436 getBytesUTF8 :: String -> ByteArray
1437 getBytesUTF8 str = getBytes str "UTF-8"
1439 instance Ord String where
1440 compare = compareString
1442 instance Additive String where
1445 sum ss = runProc (StringBuilder.toString $ foldl StringBuilder.appendString StringBuilder.new ss)
1448 importJava "org.simantics.scl.runtime.string.StringEscape" where
1449 appendEscapedString :: StringBuilder.T -> String -> <Proc> StringBuilder.T
1451 instance Show String where
1452 showForPrinting = id
1453 sb <+ v = (appendEscapedString (sb << "\"") v) << "\""
1455 instance Read String where
1458 @deprecated "Instead of 'splitString text pattern', write 'split pattern text' (note change in the parameter order)."
1459 "`splitString text pattern` splits the string into a list of string where the parts are sepratated in the original list by the given pattern."
1460 splitString :: String -> String -> [String]
1461 splitString source pattern = arrayToList $ splitString_ source pattern
1464 `split pattern text` splits `text` around matches of the given regular expression `pattern`.
1466 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.
1468 The string "boo:and:foo", for example, yields the following results with these expressions:
1471 : { "boo", "and", "foo" }
1472 o { "b", "", ":and:f" }
1474 split :: String -> String -> [String]
1475 split pattern text = arrayToList $ splitString_ text pattern
1479 instance Ord () where
1482 instance Additive () where
1486 instance Show () where
1491 "Gives the first element of a pair."
1496 "Gives the second element of a pair."
1502 mapFst :: (a -> b) -> (a,c) -> (b,c)
1503 mapFst f (x,y) = (f x, y)
1506 mapSnd :: (a -> b) -> (c,a) -> (c,b)
1507 mapSnd f (x,y) = (x, f y)
1509 instance (Ord a, Ord b) => Ord (a, b) where
1510 compare (a0, b0) (a1, b1) = compare a0 a1 &<& compare b0 b1
1512 instance (Additive a, Additive b) => Additive (a, b) where
1514 (a0, b0) + (a1, b1) = (a0+a1, b0+b1)
1516 instance Functor ((,) a) where
1517 fmap f (a,b) = (a, f b)
1519 instance (Show a, Show b) => Show (a, b) where
1520 sb <+ (x, y) = sb << "(" <+ x << ", " <+ y << ")"
1524 instance (Ord a, Ord b, Ord c) => Ord (a, b, c) where
1525 compare (a0, b0, c0) (a1, b1, c1) = compare a0 a1 &<& compare b0 b1 &<& compare c0 c1
1527 instance (Additive a, Additive b, Additive c) => Additive (a, b, c) where
1528 zero = (zero, zero, zero)
1529 (a0, b0, c0) + (a1, b1, c1) = (a0+a1, b0+b1, c0+c1)
1531 instance Functor ((,,) a b) where
1532 fmap f (a,b,c) = (a, b, f c)
1534 instance (Show a, Show b, Show c) => Show (a, b, c) where
1535 sb <+ (x, y, z) = sb << "(" <+ x << ", " <+ y << ", " <+ z << ")"
1539 instance (Ord a, Ord b, Ord c, Ord d) => Ord (a, b, c, d) where
1540 compare (a0, b0, c0, d0) (a1, b1, c1, d1) =
1541 compare a0 a1 &<& compare b0 b1 &<& compare c0 c1 &<& compare d0 d1
1543 instance (Additive a, Additive b, Additive c, Additive d) => Additive (a, b, c, d) where
1544 zero = (zero, zero, zero, zero)
1545 (a0, b0, c0, d0) + (a1, b1, c1, d1) = (a0+a1, b0+b1, c0+c1, d0+d1)
1547 instance Functor ((,,,) a b c) where
1548 fmap f (a,b,c,d) = (a, b, c, f d)
1550 instance (Show a, Show b, Show c, Show d) => Show (a, b, c, d) where
1551 sb <+ (x, y, z, w) = sb << "(" <+ x << ", " <+ y << ", " <+ z << ", " <+ w << ")"
1555 instance (Ord a, Ord b, Ord c, Ord d, Ord e) => Ord (a, b, c, d, e) where
1556 compare (a0, b0, c0, d0, e0) (a1, b1, c1, d1, e1) =
1557 compare a0 a1 &<& compare b0 b1 &<& compare c0 c1 &<& compare d0 d1 &<& compare e0 e1
1559 instance (Additive a, Additive b, Additive c, Additive d, Additive e) => Additive (a, b, c, d, e) where
1560 zero = (zero, zero, zero, zero, zero)
1561 (a0, b0, c0, d0, e0) + (a1, b1, c1, d1, e1) = (a0+a1, b0+b1, c0+c1, d0+d1, e0+e1)
1563 instance Functor ((,,,,) a b c d) where
1564 fmap f (a,b,c,d,e) = (a, b, c, d, f e)
1568 instance (Ord a) => Ord [a] where
1569 compare a b = loop 0
1574 then (if i >= lB then 0 else -1)
1577 else compare (a!i) (b!i) &<& loop (i+1)
1579 instance Functor [] where
1582 instance FunctorE [] where
1587 instance Monad [] where
1588 return x = singletonList x
1589 l >>= f = concatMap f l
1592 instance MonadZero [] where
1595 instance MonadPlus [] where
1598 instance Additive [a] where
1602 instance FunctorM [] where
1603 sequence = foldl (\m mel -> m >>= \l -> mel >>= \el -> return (addList l el)) (return emptyList)
1604 mapM f l = sequence (map f l)
1606 "Appends the string representations of all elements of the list to the string builder and separates the values with the given separator."
1607 printWithSeparator :: Show a => StringBuilder.T -> String -> [a] -> <Proc> StringBuilder.T
1608 printWithSeparator sb sep l = loop 0
1611 loop i = if i >= len then sb
1613 (if i==0 then sb else sb << sep) <+ l!i
1617 Joins the string representations of the list of values with the given separator.
1619 See [intercalate](#intercalate) for an alternative that works with Strings
1620 and doesn't escape its arguments.
1622 joinWithSeparator :: Show a => String -> [a] -> String
1623 joinWithSeparator separator values = runProc (
1624 StringBuilder.toString $ printWithSeparator StringBuilder.new separator values)
1628 The intercalate function takes a String and a list of Strings
1629 and concatenates the list after interspersing the first argument
1630 between each element of the list.
1632 See also more generic [joinWithSeparator](#joinWithSeparator)
1633 which escapes its arguments using `show`.
1635 intercalate :: String -> [String] -> String
1636 intercalate separator strings = do
1643 sb = StringBuilder.new
1645 loop i | i == l = ()
1647 sb << separator << strings!i
1650 StringBuilder.toString sb
1652 instance (Show a) => Show [a] where
1657 if (i>0) then sb << ", " else sb
1664 importJava "java.util.List" where
1665 "`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."
1667 getList :: [a] -> Integer -> a
1671 lengthList :: [a] -> Integer
1674 subList :: [a] -> Integer -> Integer -> [a]
1677 isEmpty :: [a] -> Boolean
1680 importJava "java.util.Collections" where
1682 //singletonList :: a -> [a]
1687 emptyList = build (\empty cons -> empty)
1690 "Creates a list with exectly one element."
1692 singletonList :: a -> [a]
1693 singletonList v = build (\empty cons -> cons empty v)
1696 // foldl f i (a + b) = foldl f (foldl f i a) b
1698 appendList :: [a] -> [a] -> [a]
1699 appendList a b = build (\empty cons -> foldl cons (foldl cons empty a) b)
1702 importJava "org.simantics.scl.runtime.list.ShareableList" where
1703 "Concatenates two lists."
1706 appendList :: [a] -> [a] -> [a]
1708 "Adds the given value to the end of the list."
1710 addList :: [a] -> a -> [a]
1713 importJava "java.util.ArrayList" where
1717 newArrayList :: <Proc> ArrayList a
1720 addArrayList :: ArrayList a -> a -> <Proc> ()
1723 A primitive for constructing a list by `empty` and `cons` operations given to the function given as a parameter to this function.
1726 build (\empty cons -> cons (cons (cons empty 1) 2) 3)
1732 The SCL compiler makes the following optimization when encountering `build` and `foldl` functions after inlining:
1734 foldl f i (build g) = g i f
1737 build :: forall b e2. (forall a e1. a -> (a -> b -> <e1> a) -> <e1,e2> a) -> <e2> [b]
1738 build f = runProc do
1740 f () (\_ v -> addArrayList l v)
1743 "A specific implementation of `map` for lists."
1746 mapEList :: (a -> <e> b) -> [a] -> <e> [b]
1747 mapEList f l = build (\empty cons -> foldl (\cur x -> cons cur (f x)) empty l)
1749 "A specific implementation of `fmap` for lists."
1751 mapList :: (a -> b) -> [a] -> [b]
1752 mapList f l = build (\empty cons -> foldl (\cur x -> cons cur (f x)) empty l)
1754 "`guardList v` returns a singleton `[()]` if `v=True` and the empty list if `v=False`."
1756 guardList :: Boolean -> [()]
1757 guardList cond = build (\empty cons -> if cond then cons empty () else empty)
1760 `concatMap` combines `map` and `join` functions.
1761 It maps the elements of a given list to lists with the given function and concatenates the results.
1763 concatMap f lst = join (map f lst) = [y | x <- lst, y <- f x]
1766 concatMap :: (a -> <e> [b]) -> [a] -> <e> [b]
1767 concatMap f l = build (\empty cons -> foldl (\cur le -> foldl cons cur (f le)) empty l)
1770 Applies the given function to the elements of the lists until the function returns something
1771 else than `Nothing`. This return value is also returned as a result of this function.
1774 mapFirst :: (a -> <e> Maybe b) -> [a] -> <e> Maybe b
1775 mapFirst f l = loop 0
1778 loop i = if i == len
1780 else match f (l!i) with
1782 Nothing -> loop (i+1)
1785 foldl op initialValue list
1787 applies a binary operator `op` to all elements of `list` from left to right
1788 starting with `initialValue`. For example,
1790 foldl op init [x1, x2, x3, x4] = (((init `op` x1) `op` x2) `op` x3) `op` x4
1793 foldl :: forall a b e. (a -> b -> <e> a) -> a -> [b] -> <e> a
1794 foldl f initial l = loop initial 0
1797 loop cur i = if i==len
1799 else loop (f cur (l!i)) (i+1)
1801 foldlI :: forall a b e. (Integer -> a -> b -> <e> a) -> a -> [b] -> <e> a
1802 foldlI f initial l = loop initial 0
1805 loop cur i = if i==len
1807 else loop (f i cur (l!i)) (i+1)
1809 scanl :: (b -> a -> <e> b) -> b -> [a] -> <e> [b]
1810 scanl f initial l = build (\empty cons -> let
1812 loop cur i accum = let nl = cons accum cur
1815 else loop (f cur (l!i)) (i+1) nl
1816 in loop initial 0 empty)
1818 "`foldr` is defined like `foldl` but it process the list from right to left."
1820 foldr :: (b -> a -> <e> a) -> a -> [b] -> <e> a
1821 foldr f initial l = loop initial (length l - 1)
1823 loop cur i = if i < 0
1825 else loop (f (l!i) cur) (i-1)
1827 foldr1 :: (a -> a -> <e> a) -> [a] -> <e> a
1828 foldr1 f l = loop (l!(len-1)) (len-2)
1831 loop cur i = if i < 0
1833 else loop (f (l!i) cur) (i-1)
1836 `filter pred lst` returns those elements of `lst` that the predicate `pred` accepts. For example
1838 filter (> 3) [1, 2, 3, 4, 5, 6] = [4, 5, 6]
1841 filter :: (a -> <e> Boolean) -> [a] -> <e> [a]
1842 filter p l = build (\empty cons -> foldl (\cur x -> if p x then cons cur x else cur) empty l)
1845 Takes those elements of the input list that match `(Just x)` and adds the contents to the resulting list. For example,
1847 filterJust [Just 1, Nothing, Just 5] = [1, 5]
1850 filterJust :: [Maybe a] -> [a]
1851 filterJust l = build (\empty cons -> foldl (\cur x -> match x with Just v -> cons cur v ; _ -> cur) empty l)
1853 listToMaybe :: [a] -> Maybe a
1854 listToMaybe l = if isEmpty l then Nothing else Just (l!0)
1856 maybeToList :: Maybe a -> [a]
1857 maybeToList (Just a) = [a]
1861 `takeWhile p l`, returns the longest prefix (possibly empty) of list `l` of elements that satisfy `p`
1863 takeWhile :: (a -> <e> Boolean) -> [a] -> <e> [a]
1864 takeWhile f l = loop 0
1867 loop i | i == len = l
1868 | f (l!i) = loop (i+1)
1869 | otherwise = take i l
1871 partition :: (a -> <e> Boolean) -> [a] -> <e> ([a], [a])
1872 partition p l = runProc do
1877 then addArrayList res1 el
1878 else addArrayList res2 el
1880 (Java.unsafeCoerce res1, Java.unsafeCoerce res2)
1883 `range begin end` produces a list of consecutive integers starting from `begin` and ending to `end` (including `end`).
1884 The compiler supports syntactic sugar `[begin..end]` for this function.
1887 range :: Integer -> Integer -> [Integer]
1888 range first last = build (\empty cons -> do
1889 loop i cur = if i > last then cur else loop (i+1) (cons cur i)
1892 "A specific implementation of `iter` for lists."
1894 iterList :: (a -> <e> b) -> [a] -> <e> ()
1895 iterList f l = foldl (\_ x -> ignore (f x)) () l
1897 "A specific implementation of `iterI` for lists."
1899 iterIList :: (Integer -> a -> <e> b) -> [a] -> <e> ()
1900 iterIList f l = do foldl (\i x -> do f i x ; i+1) 0 l ; ()
1903 Generates a list from a given starting state and iteration function.
1906 let nextState 0 = Nothing
1907 nextState i = Just (i, i `div` 2)
1908 in unfoldr nextState 30
1915 unfoldr :: (b -> <e> Maybe (a, b)) -> b -> <e> [a]
1916 unfoldr f s = build (\empty cons -> do
1919 Just (el,newS) -> loop newS (cons cur el)
1923 importJava "org.simantics.scl.runtime.Lists" where
1927 mapList :: (a -> b) -> [a] -> [b]
1930 mapEList :: (a -> <e> b) -> [a] -> <e> [b]
1933 iterList :: (a -> <e> ()) -> [a] -> <e> ()
1934 concatMap :: (a -> <e> [b]) -> [a] -> <e> [b]
1937 Combines two lists into one list of pairs. The length of the resulting list is the length of the smallest input list.
1939 zip [1, 2, 3, 4, 5] ['a', 'b', 'c'] = [(1, 'a'), (2, 'b'), (3, 'c')]
1941 zip :: [a] -> [b] -> [(a,b)]
1942 "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."
1943 zipWith :: (a -> b -> <e> c) -> [a] -> [b] -> <e> [c]
1945 Produces two lists from one list of pairs.
1947 unzip [(1, 'a'), (2, 'b'), (3, 'c')] = ([1, 2, 3], ['a', 'b', 'c'])
1949 unzip :: [(a,b)] -> ([a],[b])
1951 //"@filter p l@ returns those elements of @l@ that the predicate @p@ accepts."
1952 //filter :: (a -> <e> Boolean) -> [a] -> <e> [a]
1953 //filterJust :: [Maybe a] -> [a]
1955 foldl :: (a -> b -> <e> a) -> a -> [b] -> <e> a
1957 "Like `foldl` but assumes that the list is non-empty so the initial is not needed."
1958 foldl1 :: (a -> a -> <e> a) -> [a] -> <e> a
1959 //unfoldr :: (b -> <e> Maybe (a, b)) -> b -> <e> [a]
1961 "Sorts the list using the given comparator."
1962 sortWith :: (a -> a -> <e> Integer) -> [a] -> <e> [a]
1965 Given a list of key-value pairs, the function produces a function that finds a value
1966 efficiently for the given key.
1968 index :: [(a,b)] -> a -> Maybe b
1971 Given a list of values and a function computing a key for each value, the function produces a function that finds a value
1972 effeciently for the given key.
1974 indexBy :: (a -> <e> b) -> [a] -> <e> (b -> Maybe a)
1976 "Works like `index` but uses the given functions as hash codes and equality."
1977 indexWith :: (a -> Integer) -> (a -> a -> Boolean) -> [(a,b)] -> a -> Maybe b
1979 "Groups a list values by a key computed by the given function."
1980 groupBy :: (a -> <e> b) -> [a] -> <e> [(b, [a])]
1982 "Groups a list of key-value pairs by the keys."
1983 group :: [(a,b)] -> [(a, [b])]
1985 "Composition of index and groupBy."
1986 indexGroupBy :: (a -> <e> b) -> [a] -> <e> (b -> [a])
1988 "Composition of index and group."
1989 indexGroup :: [(a,b)] -> a -> [b]
1991 groupWith :: (b -> Integer) -> (b -> b -> Boolean) -> (a -> <e> b) -> (a -> <e> c) -> [a] -> <e> [(b, [c])]
1993 "Removes duplicates (all but the first occurrence) from the list but otherwise preserves the order of the elements."
1994 unique :: [a] -> [a]
1996 "Like `unique`, but uses the given function for finding the key values used for uniqueness testing."
1997 uniqueBy :: (a -> b) -> [a] -> [a]
1999 "Works like `unique` but uses the given function for equality tests."
2000 uniqueWith :: (a -> a -> Boolean) -> [a] -> [a]
2002 "Works like `\\\\` but uses the given function for equality tests."
2003 deleteAllBy :: (a -> a -> Boolean) -> [a] -> [a] -> [a]
2006 listDifference :: [a] -> [a] -> [a]
2008 //range :: Integer -> Integer -> [Integer]
2010 //build :: (forall a. a -> (a -> b -> <e> a) -> <e> a) -> <e> [b]
2012 "`elem el lst` return true, if `el` occurs in the list `lst`."
2013 elem :: a -> [a] -> Boolean
2017 loop i | i < len = if el == l!i
2022 "`elemMaybe v1 (Just v2)` returns true if `v1 == v2`. `elemMaybe v1 Nothing` is always false."
2023 elemMaybe :: a -> Maybe a -> Boolean
2024 elemMaybe el m = match m with
2025 Just el2 -> el == el2
2028 "`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."
2029 elemIndex :: a -> [a] -> Maybe Integer
2030 elemIndex el l = loop 0
2033 loop i | i < len = if el == l!i
2036 | otherwise = Nothing
2039 Computes a list that contains only elements that belongs to both input lists.
2041 intersect :: [a] -> [a] -> [a]
2042 intersect a b = filter f a
2046 "Reverses a given list. For example, `reverse [1,2,3] = [3,2,1]`"
2047 reverse :: [a] -> [a]
2048 reverse l = [l!(len-i) | i <- [1..len]]
2053 Transposes the rows and columns of its argument. For example,
2055 transpose [[1,2,3],[4,5,6]] == [[1,4],[2,5],[3,6]]
2056 transpose [[1,2],[3,4,5]] == [[1,3],[2,4],[5]]
2058 transpose xss = [[xs!i | xs <- xss, i < length xs]
2059 | i <- [0..maximum [length xs | xs <- xss]-1]]
2061 "Works like `unfoldr` but generates the list from right to left."
2062 unfoldl :: (b -> <e> Maybe (a, b)) -> b -> <e> [a]
2063 unfoldl f seed = reverse $ unfoldr f seed
2065 "Removes the first element of the list, if the list is non-empty."
2067 tail l = if len < 2 then emptyList else subList l 1 len
2071 "Tries to find the given key from the list of key-value pairs and returns the corresponding value."
2072 lookup :: a -> [(a, b)] -> Maybe b
2077 (a,b) | a == el -> Just b
2078 | otherwise -> loop (i+1)
2082 "Conjunction over a list."
2084 and :: [Boolean] -> Boolean
2085 and = foldl (&&) True
2087 "Disjunction over a list."
2089 or :: [Boolean] -> Boolean
2090 or = foldl (||) False
2093 `any pred lst` tests whether the predicate `pred` holds some element of `lst`.
2094 It returns immediately when it encounters the first value satisfying the predicate.
2096 any :: (a -> <e> Boolean) -> [a] -> <e> Boolean
2100 `all pred lst` tests whether the predicate `pred` holds for all elements of `lst`.
2101 It returns immediately when it encounters the first value not satisfying the predicate.
2103 all :: (a -> <e> Boolean) -> [a] -> <e> Boolean
2107 Returns the first element of the list satisfying the given condition,
2108 or `Nothing` if there is no such element.
2110 findFirst :: (a -> <e> Boolean) -> [a] -> <e> Maybe a
2111 findFirst p l = loop 0
2115 then let el = l!i in
2124 Sorts the given list using its default order.
2127 sort :: Ord a => [a] -> [a]
2128 sort = sortWith compare
2131 Sorts the lists by the values computed by the first function.
2134 sortBy snd [(1,5), (2,3), (3,4)] = [(2,3), (3,4), (1,5)]
2137 sortBy :: Ord b => (a -> <e> b) -> [a] -> <e> [a]
2138 sortBy f l = sortWith (\x y -> compare (f x) (f y)) l
2139 // This is faster if f is slow, but will generate more auxiliary structures
2140 //sortBy f l = map snd (sortWith (\(x,_) (y,_) -> compare x y) [(f x, x) | x <- l])
2142 "`a \\\\ b` removes all elements of `b` from the list `a`."
2143 (\\) :: [a] -> [a] -> [a]
2144 (\\) = listDifference
2148 importJava "java.lang.Object" where
2149 "A data type that can represent any value."
2154 showDynamic :: Dynamic -> String
2156 instance Show Dynamic where
2159 "Converts a value to `Dynamic` type."
2160 toDynamic :: a -> Dynamic
2161 toDynamic = Java.unsafeCoerce
2163 "Converts a `Dynamic` value to a required value, or fails if the conversion is not possible."
2164 importJava "org.simantics.scl.compiler.runtime.ValueConversion" where
2165 fromDynamic :: Typeable a => Dynamic -> a
2169 importJava "org.simantics.scl.runtime.procedure.Ref" where
2170 "A mutable reference to a value of type `a`."
2173 "Creates a new reference with the given initial value."
2175 ref :: a -> <Proc> (Ref a)
2177 "Returns the current value of the reference."
2179 getRef :: Ref a -> <Proc> a
2181 "Sets a new value for the reference."
2182 @JavaName "<set>value"
2183 (:=) :: Ref a -> a -> <Proc> ()
2185 instance Show (Ref a) where
2186 show _ = "<reference>"
2188 importJava "org.simantics.scl.runtime.reporting.SCLReporting" where
2189 "Prints the given string to the console."
2191 printString :: String -> <Proc> ()
2192 "Prints an error message to the console."
2193 printError :: String -> <Proc> ()
2194 "Reports that certain amount of work has been done for the current task."
2195 didWork :: Double -> <Proc> ()
2197 `printingToFile "fileName" expression` executes the `expression` so that all its console prints
2198 are written to the file given as a first parameter.
2200 printingToFile :: String -> (<e> a) -> <e> a
2202 `printErrorsAsNormalPrints expression` executes the `expression` so that all its error prints
2203 are printed as normal prints. This is useful mainly in testing scripts for checking that the implementations
2204 give proper error messages with invalid inputs.
2206 printErrorsAsNormalPrints :: (<e> a) -> <e> a
2208 `disablePrintingForCommand expression` executes the `expression` so that it does not print return values.
2209 Errors are printed normally.
2211 disablePrintingForCommand :: (<e> a) -> <e> a
2214 importJava "org.simantics.scl.runtime.procedure.Procedures" where
2215 "Returns `True` if the current thread has been interrupted."
2216 isInterrupted :: <Proc> Boolean
2217 "Checks whether the current thread has been interrupted and throws an exception if it is."
2218 checkInterrupted :: <Proc> ()
2219 "Generates a random identifier."
2220 generateUID :: <Proc> String
2222 "Executes the given expression and catches certain class of exceptions (specified by the catch handler that is given as a second parameter.)"
2224 catch :: VecComp ex => (<e,Exception> a) -> (ex -> <e> a) -> <e> a
2226 importJava "java.lang.Throwable" where
2230 showThrowable :: Throwable -> String
2232 @JavaName getMessage
2233 getMessageThrowable :: Throwable -> String
2236 getCauseThrowable :: Throwable -> Maybe Throwable
2237 importJava "java.lang.Exception" where
2241 showException :: Exception -> String
2243 instance Show Throwable where
2244 show = showThrowable
2245 instance Show Exception where
2246 show = showException
2248 class Throwable e where
2249 toThrowable :: e -> Throwable
2251 messageOfException :: Throwable e => e -> String
2252 messageOfException = getMessageThrowable . toThrowable
2254 causeOfException :: Throwable e => e -> Maybe Throwable
2255 causeOfException = getCauseThrowable . toThrowable
2257 instance Throwable Throwable where
2259 instance Throwable Exception where
2260 toThrowable = Java.unsafeCoerce
2262 "Prints the given value in the console."
2264 print :: Show a => a -> <Proc> ()
2265 print v = printString (showForPrinting v)
2267 instance Show TypeRep where
2268 sb <+ (TApply (TCon "Builtin" "[]") b) =
2269 sb << "[" <+ b << "]"
2270 sb <+ (TApply (TApply (TCon "Builtin" "(,)") c1) c2) =
2271 sb << "(" <+ c1 << "," <+ c2 << ")"
2272 sb <+ (TApply (TApply (TApply (TCon "Builtin" "(,,)") c1) c2) c3) =
2273 sb << "(" <+ c1 << "," <+ c2 << "," <+ c3 << ")"
2274 sb <+ (TApply (TApply (TApply (TApply (TCon "Builtin" "(,,,)") c1) c2) c3) c4) =
2275 sb << "(" <+ c1 << "," <+ c2 << "," <+ c3 << "," <+ c4 << ")"
2277 sb <+ (TCon _ name) = sb << name
2278 sb <+ (TApply a b) = sb <+ Par 1 a << " " <+ Par 2 b
2279 sb <+ (TFun a b) = sb <+ Par 1 a << " -> " <+ b
2281 precedence (TCon _ _) = 0
2282 precedence (TFun _ _) = 2
2283 precedence (TApply a _) = if isSpecialType a then 0 else 1
2285 isSpecialType (TCon "Builtin" "[]") = True
2286 isSpecialType (TCon "Builtin" "()") = True
2287 isSpecialType (TCon "Builtin" "(,)") = True
2288 isSpecialType (TCon "Builtin" "(,,)") = True
2289 isSpecialType (TCon "Builtin" "(,,,)") = True
2290 isSpecialType (TApply a _) = isSpecialType a
2295 importJava "java.util.Arrays" where
2298 byteArrayToString :: ByteArray -> String
2300 instance Show ByteArray where
2301 show = byteArrayToString
2306 importJava "org.simantics.scl.compiler.types.Type" where
2308 showType :: Type -> String
2310 importJava "org.simantics.scl.compiler.types.Types" where
2311 removeForAll :: Type -> Type
2313 instance Show Type where