avoid list lookup by parseToken

Minor optimisation to parsing of a preferred content expression.

Annex/FileMatcher.hs

@@ -84,9 +84,9 @@ data ParseToken t
 type ParseResult t = Either String (Token t)
 
 parseToken :: [ParseToken t] -> String -> ParseResult t
-parseToken l t
+parseToken l t = case syntaxToken t of
-	| t `elem` tokens = Right $ token t
+	Right st -> Right st
-	| otherwise = go l
+	Left _ -> go l
   where
 	go [] = Left $ "near " ++ show t
 	go (SimpleToken s r : _) | s == t = r

CmdLine/GitAnnex/Options.hs

@@ -324,8 +324,8 @@ combiningOptions =
 	, shortopt ')' "close group of options"
 	]
   where
-	longopt o h = globalFlag (Limit.addToken o) ( long o <> help h <> hidden )
+	longopt o h = globalFlag (Limit.addSyntaxToken o) ( long o <> help h <> hidden )
-	shortopt o h = globalFlag (Limit.addToken [o]) ( short o <> help h <> hidden )
+	shortopt o h = globalFlag (Limit.addSyntaxToken [o]) ( short o <> help h <> hidden )
 
 jsonOptions :: [GlobalOption]
 jsonOptions = 

Limit.hs

@@ -63,9 +63,9 @@ add l = Annex.changeState $ \s -> s { Annex.limit = prepend $ Annex.limit s }
 	prepend (BuildingMatcher ls) = BuildingMatcher $ l:ls
 	prepend _ = error "internal"
 
-{- Adds a new token. -}
+{- Adds a new syntax token. -}
-addToken :: String -> Annex ()
+addSyntaxToken :: String -> Annex ()
-addToken = add . Utility.Matcher.token
+addSyntaxToken = either error add . Utility.Matcher.syntaxToken
 
 {- Adds a new limit. -}
 addLimit :: Either String (MatchFiles Annex) -> Annex ()

Logs/PreferredContent.hs

@@ -34,7 +34,7 @@ import qualified Annex.Branch
 import qualified Annex
 import Logs
 import Logs.UUIDBased
-import Utility.Matcher hiding (tokens)
+import Utility.Matcher
 import Annex.FileMatcher
 import Annex.UUID
 import Types.Group

Utility/Matcher.hs

@@ -20,8 +20,7 @@
 module Utility.Matcher (
 	Token(..),
 	Matcher(..),
-	token,
+	syntaxToken,
-	tokens,
 	generate,
 	match,
 	matchM,
@@ -47,16 +46,13 @@ data Matcher op = MAny
 	deriving (Show, Eq)
 
 {- Converts a word of syntax into a token. Doesn't handle operations. -}
-token :: String -> Token op
+syntaxToken :: String -> Either String (Token op)
-token "and" = And
+syntaxToken "and" = Right And
-token "or" = Or
+syntaxToken "or" = Right Or
-token "not" = Not
+syntaxToken "not" = Right Not
-token "(" = Open
+syntaxToken "(" = Right Open
-token ")" = Close
+syntaxToken ")" = Right Close
-token t = error $ "unknown token " ++ t
+syntaxToken t = Left $ "unknown token " ++ t
-
-tokens :: [String]
-tokens = words "and or not ( )"
 
 {- Converts a list of Tokens into a Matcher. -}
 generate :: [Token op] -> Matcher op