-
Notifications
You must be signed in to change notification settings - Fork 0
/
Condition.hs
104 lines (86 loc) · 3.02 KB
/
Condition.hs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
{-# LANGUAGE Safe #-}
{- |
Module : Condition
Description : Conditions and Situations and their environs
Copyright : (c) Andrew Ray, 2017
License : MIT
Conditions and Situations and their environs
Read syntax:
@
[!]pre_post [& [!]pre_post [& [!]pre_post ...]]
@
where @pre@ is the precondition and @post@ is the postcondition
@!@ is used for negation,
@&@ is used to combine conditions,
@#@ is used for beginning or end of word,
@_@ is used for search pattern characters
-}
module Condition (
Situation,
Condition(Always, And, If, IfNot),
applicable
) where
import Data.List (elemIndex)
import Data.List.Split
import Control.Monad (join)
import SoundGroup
import Util (strip)
{- |
A situation, written out as specified in README:
* #: beginning or end of word
* _: replacement characters
-}
type Situation = String
{- |
A condition is one of Always, a pairing of conditions,
a situation, or a negated situation, as specified in README:
* !: negates following condition
* &: combines two conditions
-}
data Condition =
Always | -- ^ Always applicable
Condition `And` Condition | -- ^ Applicable if both are applicable
If Situation | -- ^ Applicable if true
IfNot Situation -- ^ Applicable if false
deriving (Eq)
instance Read Condition where
readsPrec _ str
-- Always parse "Always" as Always
| strip str == "Always" = [(Always, "")]
-- Always parse "_" as Always
| strip str == "_" = [(Always, "")]
-- Evaluate ands separately and combine
| ispair str = [(And (read $ head conds) (read $ join $ tail conds), "")]
-- Evaluate not, removing the '!', and spaces around
| isneg str = [(IfNot $ tail $ strip str, "")]
-- If is trivial, just add If to the string and remove spaces around
| otherwise = [(If $ strip str, "")]
where
ispair = elem '&' -- check if contains pairing
conds = map strip $ splitOn "&" str -- split on pairing
isneg elt = head elt == '!' -- check if contains negation
-- inverse of Read
instance Show Condition where
show (cond1 `And` cond2) = show cond1 ++ " & " ++ show cond2
show (If situation) = situation
show (IfNot situation) = "!" ++ situation
show Always = "Always"
-- | Determines if the condition applies to the given example
-- at the suggested location.
applicable :: Condition -- ^ The condition to check against
-> [SoundGroup] -- ^ Map of SoundGroups to use
-> String -- ^ The example to check
-> Int -- ^ The position to check in the example
-> Bool -- ^ True iff the Condition is applicable in this context
applicable Always _ _ _ = True
applicable (cond1 `And` cond2) sgs str pos =
applicable cond1 sgs str pos && applicable cond2 sgs str pos
applicable (IfNot cond) sgs str pos =
not $ applicable (If cond) sgs str pos
applicable (If cond) sgs str pos =
let
baseIndex = elemIndex '_' cond :: Maybe Int
startIndex = maybe 0 (pos -) baseIndex :: Int
checkArea = take (length cond) (drop startIndex str) :: String
in
and $ zipWith (matches sgs) cond checkArea