module Lambdabot.Util.NickEq
( Polynick
, nickMatches
, readPolynick
, showPolynick
, lookupMononickMap
, mononickToPolynick
) where
import Lambdabot.Message
import Lambdabot.Monad
import Lambdabot.Nick
import Data.List (intercalate)
import Data.List.Split (splitOn)
import qualified Data.Map as M
import Data.Maybe (mapMaybe)
data Polynick = Polynick [Nick] deriving (Polynick -> Polynick -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Polynick -> Polynick -> Bool
$c/= :: Polynick -> Polynick -> Bool
== :: Polynick -> Polynick -> Bool
$c== :: Polynick -> Polynick -> Bool
Eq)
nickMatches :: LB (Nick -> Polynick -> Bool)
nickMatches :: LB (Nick -> Polynick -> Bool)
nickMatches = forall (m :: * -> *) a. Monad m => a -> m a
return Nick -> Polynick -> Bool
m'
where
m' :: Nick -> Polynick -> Bool
m' Nick
nck (Polynick [Nick]
nck2) = Nick
nck forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Nick]
nck2
readPolynick :: Message a => a -> String -> Polynick
readPolynick :: forall a. Message a => a -> String -> Polynick
readPolynick a
m = [Nick] -> Polynick
Polynick forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map (String -> String -> Nick
parseNick (forall a. Message a => a -> String
server a
m)) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Eq a => [a] -> [a] -> [[a]]
splitOn String
"|"
showPolynick :: Message a => a -> Polynick -> String
showPolynick :: forall a. Message a => a -> Polynick -> String
showPolynick a
m (Polynick [Nick]
n) = forall a. [a] -> [[a]] -> [a]
intercalate String
"|" forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
map (String -> Nick -> String
fmtNick (forall a. Message a => a -> String
server a
m)) [Nick]
n
mononickToPolynick :: Nick -> Polynick
mononickToPolynick :: Nick -> Polynick
mononickToPolynick = [Nick] -> Polynick
Polynick forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. a -> [a] -> [a]
:[])
lookupMononickMap :: LB (Polynick -> M.Map Nick a -> [(Nick,a)])
lookupMononickMap :: forall a. LB (Polynick -> Map Nick a -> [(Nick, a)])
lookupMononickMap = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall {a}. Polynick -> Map Nick a -> [(Nick, a)]
look'
where look' :: Polynick -> Map Nick a -> [(Nick, a)]
look' (Polynick [Nick]
ns) Map Nick a
m = forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe (\Nick
n -> (,) Nick
n forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup Nick
n Map Nick a
m) [Nick]
ns