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
*/
// ****************************************************************************************
// 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