{-# LANGUAGE NoImplicitPrelude
           , UnicodeSyntax
  #-}

module System.FTDI.Utils where

-------------------------------------------------------------------------------
-- Imports
-------------------------------------------------------------------------------

-- base
import Data.Bool                 ( Bool )
import Data.Bits                 ( Bits, (.|.), (.&.), complement )
import Data.Function             ( ($) )
import Data.List                 ( foldr )
import Data.Ord                  ( Ord, min, max )
import Prelude                   ( Enum, Bounded, minBound, maxBound
                                 , Num, (+), Integral
                                 , fromEnum, fromIntegral
                                 , divMod
                                 )

-- base-unicode-symbols
import Data.Bool.Unicode         ( (∧) )
import Data.Eq.Unicode           ( (≢) )
import Data.Ord.Unicode          ( (≤) )
import Data.Function.Unicode     ( (∘) )


-------------------------------------------------------------------------------
-- Utility functions
-------------------------------------------------------------------------------

genFromEnum ∷ (Enum e, Num n) ⇒ e → n
genFromEnum :: e -> n
genFromEnum = Int -> n
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> n) -> (e -> Int) -> e -> n
forall β γ α. (β -> γ) -> (α -> β) -> α -> γ
∘ e -> Int
forall a. Enum a => a -> Int
fromEnum

orBits ∷ (Num α, Bits α) ⇒ [α] → α
orBits :: [α] -> α
orBits = (α -> α -> α) -> α -> [α] -> α
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr α -> α -> α
forall a. Bits a => a -> a -> a
(.|.) α
0

andBits ∷ (Num α, Bits α) ⇒ [α] → α
andBits :: [α] -> α
andBits = (α -> α -> α) -> α -> [α] -> α
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr α -> α -> α
forall a. Bits a => a -> a -> a
(.&.) (α -> [α] -> α) -> α -> [α] -> α
forall a b. (a -> b) -> a -> b
$ α -> α
forall a. Bits a => a -> a
complement α
0

clamp ∷ (Bounded α, Ord α) ⇒ α → α
clamp :: α -> α
clamp = α -> α -> α
forall α. Ord α => α -> α -> α
atLeast α
forall a. Bounded a => a
minBound (α -> α) -> (α -> α) -> α -> α
forall β γ α. (β -> γ) -> (α -> β) -> α -> γ
∘ α -> α -> α
forall α. Ord α => α -> α -> α
atMost α
forall a. Bounded a => a
maxBound

atLeast ∷ Ord α ⇒ α → α → α
atLeast :: α -> α -> α
atLeast = α -> α -> α
forall α. Ord α => α -> α -> α
max

atMost ∷ Ord α ⇒ α → α → α
atMost :: α -> α -> α
atMost = α -> α -> α
forall α. Ord α => α -> α -> α
min

divRndUp ∷ Integral α ⇒ α → α → α
divRndUp :: α -> α -> α
divRndUp α
x α
y = let (α
d, α
m) = α
x α -> α -> (α, α)
forall a. Integral a => a -> a -> (a, a)
`divMod` α
y
               in α
d α -> α -> α
forall a. Num a => a -> a -> a
+ if α
m α -> α -> Bool
forall α. Eq α => α -> α -> Bool
≢ α
0 then α
1 else α
0

between ∷ Ord α ⇒ α → α → α → Bool
between :: α -> α -> α -> Bool
between α
lo α
hi α
x = α
lo α -> α -> Bool
forall α. Ord α => α -> α -> Bool
≤ α
x Bool -> Bool -> Bool
∧ α
x α -> α -> Bool
forall α. Ord α => α -> α -> Bool
≤ α
hi