Safe Haskell | None |
---|---|
Language | Haskell2010 |
Arithmetic.Fin
Synopsis
- incrementL :: forall (n :: Nat) (m :: Nat). Nat m -> Fin n -> Fin (m + n)
- incrementR :: forall (n :: Nat) (m :: Nat). Nat m -> Fin n -> Fin (n + m)
- incrementR# :: forall (n :: Nat) (m :: Nat). Nat# m -> Fin# n -> Fin# (n + m)
- weaken :: forall (n :: Nat) (m :: Nat). (n <= m) -> Fin n -> Fin m
- weakenL :: forall (n :: Nat) (m :: Natural). Fin n -> Fin (m + n)
- weakenR :: forall (n :: Nat) (m :: Natural). Fin n -> Fin (n + m)
- succ :: forall (n :: Nat). Nat n -> Fin n -> Maybe (Fin n)
- succ# :: forall (n :: Nat). Nat# n -> Fin# n -> MaybeFin# n
- ascend :: forall a (n :: Nat). Nat n -> a -> (Fin n -> a -> a) -> a
- ascend' :: forall a (n :: Nat). Nat n -> a -> (Fin n -> a -> a) -> a
- ascendFrom' :: forall a (m :: Nat) (n :: Nat). Nat m -> Nat n -> a -> (Fin (m + n) -> a -> a) -> a
- ascendFrom'# :: forall a (m :: Nat) (n :: Nat). Nat# m -> Nat# n -> a -> (Fin# (m + n) -> a -> a) -> a
- ascendM :: forall m a (n :: Nat). Monad m => Nat n -> a -> (Fin n -> a -> m a) -> m a
- ascendM# :: forall m a (n :: Nat). Monad m => Nat# n -> a -> (Fin# n -> a -> m a) -> m a
- ascendM_ :: forall m a (n :: Nat). Applicative m => Nat n -> (Fin n -> m a) -> m ()
- ascendM_# :: forall m a (n :: Nat). Monad m => Nat# n -> (Fin# n -> m a) -> m ()
- descend :: forall a (n :: Nat). Nat n -> a -> (Fin n -> a -> a) -> a
- descend# :: forall a (n :: Nat). Nat# n -> a -> (Fin# n -> a -> a) -> a
- descend' :: forall a (n :: Nat). Nat n -> a -> (Fin n -> a -> a) -> a
- descendM :: forall m a (n :: Nat). Monad m => Nat n -> a -> (Fin n -> a -> m a) -> m a
- descendM_ :: forall m a (n :: Nat). Applicative m => Nat n -> (Fin n -> m a) -> m ()
- ascending :: forall (n :: Nat). Nat n -> [Fin n]
- descending :: forall (n :: Nat). Nat n -> [Fin n]
- ascendingSlice :: forall (n :: Nat) (off :: Nat) (len :: Nat). Nat off -> Nat len -> ((off + len) <= n) -> [Fin n]
- descendingSlice :: forall (n :: Nat) (off :: Nat) (len :: Nat). Nat off -> Nat len -> ((off + len) <= n) -> [Fin n]
- absurd :: Fin 0 -> void
- demote :: forall (n :: Nat). Fin n -> Int
- demote# :: forall (n :: Nat). Fin# n -> Int#
- with :: forall (n :: Nat) a. Fin n -> (forall (i :: Nat). (i < n) -> Nat i -> a) -> a
- with# :: forall (n :: Nat) a. Fin# n -> (forall (i :: Nat). (i <# n) -> Nat# i -> a) -> a
- construct# :: forall (i :: Nat) (n :: Nat). (i <# n) -> Nat# i -> Fin# n
- remInt# :: forall (n :: Nat). Int# -> Nat# n -> Fin# n
- remWord# :: forall (n :: Nat). Word# -> Nat# n -> Fin# n
- fromInt :: forall (n :: Nat). Nat n -> Int -> Maybe (Fin n)
- fromInt# :: forall (n :: Nat). Nat# n -> Int# -> MaybeFin# n
- lift :: forall (n :: Nat). Fin# n -> Fin n
- unlift :: forall (n :: Nat). Fin n -> Fin# n
Modification
incrementL :: forall (n :: Nat) (m :: Nat). Nat m -> Fin n -> Fin (m + n) #
Raise the index by m
and weaken the bound by m
, adding
m
to the left-hand side of n
.
incrementR :: forall (n :: Nat) (m :: Nat). Nat m -> Fin n -> Fin (n + m) #
Raise the index by m
and weaken the bound by m
, adding
m
to the right-hand side of n
.
weaken :: forall (n :: Nat) (m :: Nat). (n <= m) -> Fin n -> Fin m #
Weaken the bound, replacing it by another number greater than or equal to itself. This does not change the index.
weakenL :: forall (n :: Nat) (m :: Natural). Fin n -> Fin (m + n) #
Weaken the bound by m
, adding it to the left-hand side of
the existing bound. This does not change the index.
weakenR :: forall (n :: Nat) (m :: Natural). Fin n -> Fin (n + m) #
Weaken the bound by m
, adding it to the right-hand side of
the existing bound. This does not change the index.
succ :: forall (n :: Nat). Nat n -> Fin n -> Maybe (Fin n) #
Return the successor of the Fin or return nothing if the argument is the greatest inhabitant.
succ# :: forall (n :: Nat). Nat# n -> Fin# n -> MaybeFin# n #
Variant of succ
for unlifted finite numbers.
Traverse
These use the terms ascend
and descend
rather than the
more popular l
(left) and r
(right) that pervade the Haskell
ecosystem. The general rule is that ascending functions pair
the initial accumulator with zero with descending functions
pair the initial accumulator with the last index.
ascend :: forall a (n :: Nat). Nat n -> a -> (Fin n -> a -> a) -> a #
Fold over the numbers bounded by n
in ascending order. This
is lazy in the accumulator.
ascend 4 z f = f 3 (f 2 (f 1 (f 0 z)))
Arguments
:: forall a (n :: Nat). Nat n | Upper bound |
-> a | Initial accumulator |
-> (Fin n -> a -> a) | Update accumulator |
-> a |
Strict fold over the numbers bounded by n
in ascending
order. For convenince, this differs from foldl'
in the
order of the parameters.
ascend' 4 z f = f 3 (f 2 (f 1 (f 0 z)))
Arguments
:: forall a (m :: Nat) (n :: Nat). Nat m | Index to start at |
-> Nat n | Number of steps to take |
-> a | Initial accumulator |
-> (Fin (m + n) -> a -> a) | Update accumulator |
-> a |
Generalization of ascend'
that lets the caller pick the starting index:
ascend' === ascendFrom' 0
Arguments
:: forall a (m :: Nat) (n :: Nat). Nat# m | Index to start at |
-> Nat# n | Number of steps to take |
-> a | Initial accumulator |
-> (Fin# (m + n) -> a -> a) | Update accumulator |
-> a |
Variant of ascendFrom'
with unboxed arguments.
Arguments
:: forall m a (n :: Nat). Monad m | |
=> Nat n | Upper bound |
-> a | Initial accumulator |
-> (Fin n -> a -> m a) | Update accumulator |
-> m a |
Strict monadic left fold over the numbers bounded by n
in ascending order. Roughly:
ascendM 4 z0 f = f 0 z0 >>= \z1 -> f 1 z1 >>= \z2 -> f 2 z2 >>= \z3 -> f 3 z3
Arguments
:: forall m a (n :: Nat). Monad m | |
=> Nat# n | Upper bound |
-> a | Initial accumulator |
-> (Fin# n -> a -> m a) | Update accumulator |
-> m a |
Variant of ascendM
that takes an unboxed Nat and provides
an unboxed Fin to the callback.
Arguments
:: forall m a (n :: Nat). Applicative m | |
=> Nat n | Upper bound |
-> (Fin n -> m a) | Effectful interpretion |
-> m () |
Monadic traversal of the numbers bounded by n
in ascending order.
ascendM_ 4 f = f 0 *> f 1 *> f 2 *> f 3
Arguments
:: forall m a (n :: Nat). Monad m | |
=> Nat# n | Upper bound |
-> (Fin# n -> m a) | Update accumulator |
-> m () |
Variant of ascendM_
that takes an unboxed Nat and provides
an unboxed Fin to the callback.
Arguments
:: forall a (n :: Nat). Nat n | Upper bound |
-> a | Initial accumulator |
-> (Fin n -> a -> a) | Update accumulator |
-> a |
Fold over the numbers bounded by n
in descending
order. This is lazy in the accumulator. For convenince,
this differs from foldr
in the order of the parameters.
descend 4 z f = f 0 (f 1 (f 2 (f 3 z)))
Arguments
:: forall a (n :: Nat). Nat n | Upper bound |
-> a | Initial accumulator |
-> (Fin n -> a -> a) | Update accumulator |
-> a |
Fold over the numbers bounded by n
in descending
order. This is strict in the accumulator. For convenince,
this differs from foldr'
in the order of the parameters.
descend 4 z f = f 0 (f 1 (f 2 (f 3 z)))
descendM :: forall m a (n :: Nat). Monad m => Nat n -> a -> (Fin n -> a -> m a) -> m a #
Strict monadic left fold over the numbers bounded by n
in descending order. Roughly:
descendM 4 z f = f 3 z0 >>= \z1 -> f 2 z1 >>= \z2 -> f 1 z2 >>= \z3 -> f 0 z3
Arguments
:: forall m a (n :: Nat). Applicative m | |
=> Nat n | Upper bound |
-> (Fin n -> m a) | Effectful interpretion |
-> m () |
Monadic traversal of the numbers bounded by n
in descending order.
descendM_ 4 f = f 3 *> f 2 *> f 1 *> f 0
ascending :: forall (n :: Nat). Nat n -> [Fin n] #
Generate all values of a finite set in ascending order.
>>>
ascending (Nat.constant @3)
[Fin 0,Fin 1,Fin 2]
descending :: forall (n :: Nat). Nat n -> [Fin n] #
Generate all values of a finite set in descending order.
>>>
descending (Nat.constant @3)
[Fin 2,Fin 1,Fin 0]
ascendingSlice :: forall (n :: Nat) (off :: Nat) (len :: Nat). Nat off -> Nat len -> ((off + len) <= n) -> [Fin n] #
Generate len
values starting from off
in ascending order.
>>>
ascendingSlice (Nat.constant @2) (Nat.constant @3) (Lte.constant @_ @6)
[Fin 2,Fin 3,Fin 4]
descendingSlice :: forall (n :: Nat) (off :: Nat) (len :: Nat). Nat off -> Nat len -> ((off + len) <= n) -> [Fin n] #
Generate len
values starting from 'off + len - 1' in descending order.
>>>
descendingSlice (Nat.constant @2) (Nat.constant @3) (Lt.constant @6)
[Fin 4,Fin 3,Fin 2]
Absurdities
Demote
demote :: forall (n :: Nat). Fin n -> Int #
Extract the Int
from a 'Fin n'. This is intended to be used
at a boundary where a safe interface meets the unsafe primitives
on top of which it is built.
Deconstruct
with :: forall (n :: Nat) a. Fin n -> (forall (i :: Nat). (i < n) -> Nat i -> a) -> a #
Consume the natural number and the proof in the Fin.
with# :: forall (n :: Nat) a. Fin# n -> (forall (i :: Nat). (i <# n) -> Nat# i -> a) -> a #
Variant of with
for unboxed argument and result types.
Construct
remInt# :: forall (n :: Nat). Int# -> Nat# n -> Fin# n #
This crashes if n = 0
. Divides i
by n
and takes
the remainder.
remWord# :: forall (n :: Nat). Word# -> Nat# n -> Fin# n #
This crashes if n = 0
. Divides i
by n
and takes
the remainder.
Convert an Int to a finite number, testing that it is less than the upper bound. This crashes with an uncatchable exception when given a negative number.
Unboxed variant of fromInt
.