infix 4 (!=), (<), (<=), (>=), (>)
infixr 3 (&&), (&<&)
infixr 2 (||), orElse, morelse
-infixr 1 (>>=), (>>), (:=)
+infixr 1 (>>=), (>>), (:=), (>=>)
infixr 1 ($)
infixl 1 catch
flip :: (a -> b -> <e> c) -> b -> a -> <e> c
flip f x y = f y x
+"Swaps the order of elements of a pair (2-tuple)."
swap :: (a,b) -> (b,a)
swap (x,y) = (y,x)
(>>) :: Monad m => m a -> m b -> m b
a >> b = a >>= (\_ -> b)
+"Left-to-right Kleisli composition of monads."
+(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> (a -> m c)
+(f >=> g) x = (f x) >>= g
+
"While loop. `while cond body` executes the `body` while the `cond` is true."
@inline
while :: (<e> Boolean) -> (<e> a) -> <e> ()
Right v -> addArrayList r v)
(Java.unsafeCoerce l, Java.unsafeCoerce r)
+"`replicate n v` returns a list of length `n` such that each element is a copy of `v`."
+@inline
+replicate :: Integer -> a -> [a]
+replicate n v = build (\empty cons ->
+ let aux 0 l = l
+ aux i l = aux (i-1) (cons l v)
+ in aux n empty
+ )
+
/// FunctorM ///
class (Functor f) => FunctorM f where
The `Either` type is sometimes used to represent a value which is either correct or an error; by convention, the `Left` constructor
is used to hold an error value and the `Right` constructor is used to hold a correct value (mnemonic: "right" also means "correct").
"""
-data Either a b = Left a | Right b
+@JavaType "org.simantics.scl.runtime.either.Either"
+data Either a b =
+ @JavaType "org.simantics.scl.runtime.either.Left"
+ @FieldNames [value]
+ Left a
+ | @JavaType "org.simantics.scl.runtime.either.Right"
+ @FieldNames [value]
+ Right b
deriving instance (Ord a, Ord b) => Ord (Either a b)
deriving instance (Show a, Show b) => Show (Either a b)
instance Read String where
read str = str
+@deprecated "Instead of 'splitString text pattern', write 'split pattern text' (note change in the parameter order)."
"`splitString text pattern` splits the string into a list of string where the parts are sepratated in the original list by the given pattern."
splitString :: String -> String -> [String]
splitString source pattern = arrayToList $ splitString_ source pattern
+"""
+`split pattern text` splits `text` around matches of the given regular expression `pattern`.
+
+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.
+
+The string "boo:and:foo", for example, yields the following results with these expressions:
+
+ Regex Result
+ : { "boo", "and", "foo" }
+ o { "b", "", ":and:f" }
+"""
split :: String -> String -> [String]
split pattern text = arrayToList $ splitString_ text pattern
(if i==0 then sb else sb << sep) <+ l!i
loop (i+1)
-"Joins the string representations of the list of values with the given separator."
+"""
+Joins the string representations of the list of values with the given separator.
+
+See [intercalate](#intercalate) for an alternative that works with Strings
+and doesn't escape its arguments.
+"""
joinWithSeparator :: Show a => String -> [a] -> String
joinWithSeparator separator values = runProc (
StringBuilder.toString $ printWithSeparator StringBuilder.new separator values)
+
+"""
+The intercalate function takes a String and a list of Strings
+and concatenates the list after interspersing the first argument
+between each element of the list.
+
+See also more generic [joinWithSeparator](#joinWithSeparator)
+which escapes its arguments using `show`.
+"""
+intercalate :: String -> [String] -> String
+intercalate separator strings = do
+ l = length strings
+ if l == 0
+ then ""
+ else if l == 1
+ then strings!0
+ else runProc do
+ sb = StringBuilder.new
+ sb << strings!0
+ loop i | i == l = ()
+ | otherwise = do
+ sb << separator << strings!i
+ loop (i+1)
+ loop 1
+ StringBuilder.toString sb
+
instance (Show a) => Show [a] where
sb <+ l = do
len = length l
"Executes the given expression and catches certain class of exceptions (specified by the catch handler that is given as a second parameter.)"
@JavaName catch_
- catch :: VecComp ex => (<e> a) -> (ex -> <e> a) -> <e> a
+ catch :: VecComp ex => (<e,Exception> a) -> (ex -> <e> a) -> <e> a
importJava "java.lang.Throwable" where
data Throwable