mirror of
https://github.com/unisonweb/unison.git
synced 2024-10-26 11:07:48 +03:00
203 lines
6.7 KiB
Plaintext
203 lines
6.7 KiB
Plaintext
identity : ∀ a . a -> a;
|
|
identity a = a;
|
|
|
|
const x y = x;
|
|
|
|
then : ∀ a b c . (a -> b) -> (b -> c) -> a -> c;
|
|
then f1 f2 x = f2 (f1 x);
|
|
|
|
(|>) : ∀ a b . a -> (a -> b) -> b;
|
|
a |> f = f a;
|
|
|
|
(<|) : ∀ a b . (a -> b) -> a -> b;
|
|
f <| a = f a;
|
|
|
|
flip : ∀ a b c . (a -> b -> c) -> b -> a -> c;
|
|
flip f b a = f a b;
|
|
|
|
first : ∀ a b . Pair a b -> a;
|
|
first p = Pair.fold const p;
|
|
|
|
rest : ∀ a b . Pair a b -> b;
|
|
rest p = Pair.fold (x y -> y) p;
|
|
|
|
1st = first;
|
|
2nd = rest `then` first;
|
|
3rd = rest `then` (rest `then` first);
|
|
4th = rest `then` (rest `then` (rest `then` first));
|
|
5th = rest `then` (rest `then` (rest `then` (rest `then` first)));
|
|
|
|
set-1st : ∀ a a2 b . a2 -> Pair a b -> Pair a2 b;
|
|
set-1st new-first p = Pair new-first (rest p);
|
|
|
|
Order.compare : ∀ a . Order a -> a -> a -> Comparison;
|
|
Order.compare o a1 a2 = Order.Key.compare (Order.key o a1) (Order.key o a2);
|
|
|
|
Order.tuple2 : ∀ a b . Order a -> Order b -> Order (a,b);
|
|
Order.tuple2 a b = Pair.Order a (Pair.Order b Unit.Order);
|
|
|
|
Order.tuple3 : ∀ a b c . Order a -> Order b -> Order c -> Order (a,b,c);
|
|
Order.tuple3 a b c = Pair.Order a (Pair.Order b (Pair.Order c Unit.Order));
|
|
|
|
Order.by-1st : ∀ a b . Order a -> Order (Pair a b);
|
|
Order.by-1st a = Pair.Order a Order.ignore;
|
|
|
|
Order.by-2nd : ∀ a b c . Order b -> Order (Pair a (Pair b c));
|
|
Order.by-2nd b = Pair.Order Order.ignore (Pair.Order b Order.ignore);
|
|
|
|
Order.by-3rd : ∀ a b c d . Order c -> Order (Pair a (Pair b (Pair c d)));
|
|
Order.by-3rd c = Pair.Order Order.ignore (Pair.Order Order.ignore (Pair.Order c Order.ignore));
|
|
|
|
Vector.bind : ∀ a b . (a -> Vector b) -> Vector a -> Vector b;
|
|
Vector.bind f v = Vector.fold-balanced Vector.concatenate Vector.empty (Vector.map f v);
|
|
|
|
Vector.pure = Vector.single;
|
|
|
|
Vector.replicate : ∀ a . Number -> a -> Vector a;
|
|
Vector.replicate n a = Vector.map (const a) (Vector.range 0 n);
|
|
|
|
Vector.fold-right : ∀ a b . (a -> b -> b) -> b -> Vector a -> b;
|
|
Vector.fold-right f z vs = Vector.fold-left (flip f) z (Vector.reverse vs);
|
|
|
|
Vector.fold-balanced : ∀ a . (a -> a -> a) -> a -> Vector a -> a;
|
|
Vector.fold-balanced plus zero vs =
|
|
let rec
|
|
go plus zero vs =
|
|
if (Vector.size vs <=_Number 2)
|
|
(Vector.fold-left plus zero vs)
|
|
(let p = Vector.halve vs;
|
|
go plus zero (1st p) `plus` go plus zero (2nd p);;);
|
|
go plus zero vs;;
|
|
;
|
|
|
|
Vector.all? : ∀ a . (a -> Boolean) -> Vector a -> Boolean;
|
|
Vector.all? f vs = Vector.fold-balanced and True (Vector.map f vs);
|
|
|
|
Vector.sort : ∀ k a . Order k -> (a -> k) -> Vector a -> Vector a;
|
|
Vector.sort ok f v = Vector.sort-keyed (f `then` Order.key ok) v;
|
|
|
|
Vector.sort' : ∀ a . Order a -> Vector a -> Vector a;
|
|
Vector.sort' o = Vector.sort o identity;
|
|
|
|
Remote.map : ∀ a b . (a -> b) -> Remote a -> Remote b;
|
|
Remote.map f = Remote.bind (f `then` Remote.pure);
|
|
|
|
Remote.map2 : ∀ a b c . (a -> b -> c) -> Remote a -> Remote b -> Remote c;
|
|
Remote.map2 f a b = do Remote
|
|
a := a;
|
|
b := b;
|
|
pure (f a b);;
|
|
;
|
|
|
|
Remote.map2' : ∀ a b c . (a -> b -> Remote c) -> Remote a -> Remote b -> Remote c;
|
|
Remote.map2' f a b = Remote.map2 f a b |> Remote.join;
|
|
|
|
Remote.join : ∀ a . Remote (Remote a) -> Remote a;
|
|
Remote.join = Remote.bind identity;
|
|
|
|
Remote.replicate : ∀ a . Number -> Remote a -> Remote (Vector a);
|
|
Remote.replicate n r = Remote.sequence (Vector.replicate n r);
|
|
|
|
Remote.unfold : ∀ s a . s -> (s -> Remote (Optional (a, s))) -> Remote (Vector a);
|
|
Remote.unfold s f = let rec
|
|
go s acc = do Remote
|
|
ht := f s;
|
|
ht |> Optional.fold
|
|
(pure acc)
|
|
(ht -> go (2nd ht) (Vector.append (1st ht) acc));;
|
|
;
|
|
go s Vector.empty;;
|
|
;
|
|
|
|
Remote.transfer : Node -> Remote Unit;
|
|
Remote.transfer node = Remote.at node unit;
|
|
|
|
Remote.race : ∀ a . Duration -> Vector (Remote a) -> Remote a;
|
|
Remote.race timeout rs = do Remote
|
|
here := Remote.here;
|
|
c := Remote.channel;
|
|
result := Remote.receive-async c timeout;
|
|
Remote.traverse
|
|
(r -> Remote.fork <| do Remote a := r; Remote.transfer here; Remote.send c a;;)
|
|
rs;
|
|
result;;
|
|
;
|
|
|
|
-- Returns `None` if no response within the provided `timeout`,
|
|
-- which cannot exceed 500 seconds
|
|
Remote.timeout : ∀ a . Duration -> Remote a -> Remote (Optional a);
|
|
Remote.timeout timeout r =
|
|
Remote.race (Duration.seconds 501) [
|
|
Remote.map Some r,
|
|
do Remote Remote.delay timeout; pure None;;
|
|
];
|
|
|
|
Remote.at' : ∀ a . Node -> Remote a -> Remote a;
|
|
Remote.at' node r = do Remote Remote.transfer node; r;;;
|
|
|
|
Remote.start : ∀ a . Duration -> Remote a -> Remote (Remote a);
|
|
Remote.start timeout r = do Remote
|
|
here := Remote.here;
|
|
c := Remote.channel;
|
|
result := Remote.receive-async c timeout;
|
|
Remote.fork (Remote.at' here (r |> Remote.bind (Remote.send c)));
|
|
pure result;;
|
|
;
|
|
|
|
Remote.traverse : ∀ a b . (a -> Remote b) -> Vector a -> Remote (Vector b);
|
|
Remote.traverse f vs =
|
|
Vector.fold-balanced (Remote.map2 Vector.concatenate)
|
|
(Remote.pure Vector.empty)
|
|
(Vector.map (f `then` Remote.map Vector.single) vs);
|
|
|
|
Remote.sequence : ∀ a . Vector (Remote a) -> Remote (Vector a);
|
|
Remote.sequence vs =
|
|
Vector.fold-balanced (Remote.map2 Vector.concatenate)
|
|
(Remote.pure Vector.empty)
|
|
(Vector.map (Remote.map Vector.single) vs);
|
|
|
|
Remote.parallel-traverse : ∀ a b . Duration -> (a -> Remote b) -> Vector a -> Remote (Vector b);
|
|
Remote.parallel-traverse timeout f vs = do Remote
|
|
futures := Remote.traverse (f `then` Remote.start timeout) vs;
|
|
Remote.sequence futures;;
|
|
;
|
|
|
|
-- Run several remote computations in parallel, returning once `n` equivalent
|
|
-- replies come back. Equivalence is based on result of `hash!`.
|
|
Remote.quorum : ∀ a b . Duration -> Number -> (a -> Remote b) -> Vector a -> Remote b;
|
|
Remote.quorum timeout n = _; -- todo
|
|
|
|
Optional.map : ∀ a b . (a -> b) -> Optional a -> Optional b;
|
|
Optional.map f = Optional.fold None (f `then` Some);
|
|
|
|
Optional.bind : ∀ a b . (a -> Optional b) -> Optional a -> Optional b;
|
|
Optional.bind f = Optional.fold None f;
|
|
|
|
Optional.pure : ∀ a . a -> Optional a;
|
|
Optional.pure = Some;
|
|
|
|
Optional.getOr : ∀ a . a -> Optional a -> a;
|
|
Optional.getOr a = Optional.fold a identity;
|
|
|
|
Optional.somes : ∀ a . Vector (Optional a) -> Vector a;
|
|
Optional.somes = Vector.bind (Optional.fold Vector.empty Vector.single);
|
|
|
|
Optional.map2 : ∀ a b c . (a -> b -> c) -> Optional a -> Optional b -> Optional c;
|
|
Optional.map2 f a b = do Optional
|
|
a := a;
|
|
b := b;
|
|
pure (f a b);;
|
|
;
|
|
|
|
Either.map : ∀ a b c . (b -> c) -> Either a b -> Either a c;
|
|
Either.map f = Either.fold Left (f `then` Right);
|
|
|
|
Either.pure : ∀ a b . b -> Either a b;
|
|
Either.pure = Right;
|
|
|
|
Either.bind : ∀ a b c . (b -> Either a c) -> Either a b -> Either a c;
|
|
Either.bind = Either.fold Left;
|
|
|
|
Either.swap : ∀ a b . Either a b -> Either b a;
|
|
Either.swap e = Either.fold Right Left e;
|