Verified Commit 33ff5070 authored by John van Groningen's avatar John van Groningen Committed by Camil Staps

import module StdFunctions in module StdFunc

parent be55ff24
...@@ -5,87 +5,11 @@ definition module StdFunc ...@@ -5,87 +5,11 @@ definition module StdFunc
*/ */
// **************************************************************************************** // ****************************************************************************************
// Concurrent Clean Standard Library Module Version 2.0 // Concurrent Clean Standard Library Module Version 3.0
// Copyright 1998 University of Nijmegen // Copyright 2018 Radboud University
// **************************************************************************************** // ****************************************************************************************
/** import StdFunctions
* 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
// Some handy functions for transforming unique states: // Some handy functions for transforming unique states:
......
implementation module StdFunc implementation module StdFunc
// **************************************************************************************** // ****************************************************************************************
// Concurrent Clean Standard Library Module Version 2.0 // Concurrent Clean Standard Library Module Version 3.0
// Copyright 1995 University of Nijmegen // Copyright 2018 University of Nijmegen
// **************************************************************************************** // ****************************************************************************************
import StdClass, StdMisc, StdInt import StdClass, StdMisc, StdInt
id :: !.a -> .a import StdFunctions
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."
seq :: ![.(.s -> .s)] .s -> .s seq :: ![.(.s -> .s)] .s -> .s
seq [f:fs] arg = seq fs (f arg) seq [f:fs] arg = seq fs (f arg)
......
...@@ -5,16 +5,80 @@ definition module StdFunctions ...@@ -5,16 +5,80 @@ definition module StdFunctions
// Copyright 2018 Radboud University // 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 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) (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) * Apply a function twice.
until :: !(a -> .Bool) (a -> a) a -> a // f (f x) until (p x) *
iter :: !Int (.a -> .a) .a -> .a // f (f..(f x)..) * @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