Commit 33ff5070 by John van Groningen Committed by Camil Staps

### import module StdFunctions in module StdFunc

parent be55ff24
 ... ... @@ -5,87 +5,11 @@ definition module StdFunc */ // **************************************************************************************** // Concurrent Clean Standard Library Module Version 2.0 // Copyright 1998 University of Nijmegen // Concurrent Clean Standard Library Module Version 3.0 // Copyright 2018 Radboud University // **************************************************************************************** /** * The identity function. * * @param A value * @result The same value */ id :: !.a -> .a /** * The constant function. * * @param A value * @param Another value * @result The first value */ const :: !.a .b -> .a /** * Flip the arguments of a function. This is useful in function compositions. * * @type !.(.a -> .(.b -> .c)) .b .a -> .c * @param A function * @param The second argument to the function * @param The first argument to the function * @result The function, applied to its arguments */ flip f a b :== f b a /** * Function composition. * * @type u:(.a -> .b) u:(.c -> .a) -> u:(.c -> .b) * @param A function f * @param A function g * @result The function f o g, that is, f applied after g */ (o) infixr 9 (o) f g :== \ x -> f (g x) /** * Apply a function twice. * * @param A function f * @param A value x * @result f (f x) */ twice :: !(.a -> .a) .a -> .a /** * Apply a function as long as a property holds. * * @param A property p * @param A function f * @param An initial value x * @result x if not p x, otherwise while p f (f x) */ while :: !(a -> .Bool) (a -> a) a -> a /** * Apply a function until a property holds. * * @param A property p * @param A function f * @param An initial value x * @result x if p x, otherwise until p f (f x) */ until :: !(a -> .Bool) (a -> a) a -> a /** * Apply a function a number of times. * * @param The number of iterations n * @param The function * @param The initial value * @result The result of applying the function n times to the initial value */ iter :: !Int (.a -> .a) .a -> .a import StdFunctions // Some handy functions for transforming unique states: ... ...
 implementation module StdFunc // **************************************************************************************** // Concurrent Clean Standard Library Module Version 2.0 // Copyright 1995 University of Nijmegen // Concurrent Clean Standard Library Module Version 3.0 // Copyright 2018 University of Nijmegen // **************************************************************************************** import StdClass, StdMisc, StdInt id :: !.a -> .a id x = x const :: !.a .b -> .a const x y = x //flip::!.(.a -> .(.b -> .c)) .b .a -> .c flip f a b :== f b a (o) infixr 9; // :: u:(.a -> .b) u:(.c -> .a) -> u:(.c -> .b) (o) f g :== \ x -> f (g x) twice :: !(.a -> .a) .a -> .a twice f x = f (f x) while :: !(a -> .Bool) (a -> a) a -> a while p f x | p x = while p f (f x) = x until::!(a -> .Bool) (a -> a) a -> a until p f x | p x = x = until p f (f x) iter :: !Int (.a -> .a) .a -> .a iter 0 f x = x iter n f x | n > 0 = iter (n-1) f (f x) = abort "Error: Negative index given to iter." import StdFunctions seq :: ![.(.s -> .s)] .s -> .s seq [f:fs] arg = seq fs (f arg) ... ...
 ... ... @@ -5,16 +5,80 @@ definition module StdFunctions // Copyright 2018 Radboud University // **************************************************************************************** id :: !.a -> .a // identity function const :: !.a .b -> .a // constant function /** * The identity function. * * @param A value * @result The same value */ id :: !.a -> .a //flip :: !.(.a -> .(.b -> .c)) .b .a -> .c // Flip arguments /** * The constant function. * * @param A value * @param Another value * @result The first value */ const :: !.a .b -> .a /** * Flip the arguments of a function. This is useful in function compositions. * * @type !.(.a -> .(.b -> .c)) .b .a -> .c * @param A function * @param The second argument to the function * @param The first argument to the function * @result The function, applied to its arguments */ flip f a b :== f b a (o) infixr 9 // :: u:(.a -> .b) u:(.c -> .a) -> u:(.c -> .b) // Function composition /** * Function composition. * * @type u:(.a -> .b) u:(.c -> .a) -> u:(.c -> .b) * @param A function f * @param A function g * @result The function f o g, that is, f applied after g */ (o) infixr 9 (o) f g :== \ x -> f (g x) twice :: !(.a -> .a) .a -> .a // f (f x) while :: !(a -> .Bool) (a -> a) a -> a // while (p x) f (f x) until :: !(a -> .Bool) (a -> a) a -> a // f (f x) until (p x) iter :: !Int (.a -> .a) .a -> .a // f (f..(f x)..) /** * Apply a function twice. * * @param A function f * @param A value x * @result f (f x) */ twice :: !(.a -> .a) .a -> .a /** * Apply a function as long as a property holds. * * @param A property p * @param A function f * @param An initial value x * @result x if not p x, otherwise while p f (f x) */ while :: !(a -> .Bool) (a -> a) a -> a /** * Apply a function until a property holds. * * @param A property p * @param A function f * @param An initial value x * @result x if p x, otherwise until p f (f x) */ until :: !(a -> .Bool) (a -> a) a -> a /** * Apply a function a number of times. * * @param The number of iterations n * @param The function * @param The initial value * @result The result of applying the function n times to the initial value */ iter :: !Int (.a -> .a) .a -> .a
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment