www.jammni.de

module Term (Term, isVariable, positions, funPositions, varPositions) where
import Function
import Variable

type Pos = [Int]

data Term = F (Function Term) | V Variable

isVariable :: Term -> Bool
isVariable (F _) = False
isVariable (V _) = True

-- Hilfstyp zur Fallunterscheidung in positions'
data Ptype = All | Var | Fun
instance Eq Ptype where
     All == All = True
     Var == Var = True
     Fun == Fun = True
     x == y = False

-- my ... aktuelle Position in der Rekursion
positions' :: Ptype -> Pos -> Term -> [Pos]
positions' pt my (V _) = let pos | pt == All = [my]
                                 | pt == Var = [my]
                                 | pt == Fun = []
                         in pos
positions' pt my (F t) = let pos | pt == All = [my]
                                 | pt == Var = []
                                 | pt == Fun = [my] 
-- arity liefert die Anzahl der Argumente und args die Argumente selbst. Beide aus Function
-- *********** Das kann ich in zwei Wochen sicher nicht mehr lesen! **********************
                         in pos ++ concat (map (\(p,a) -> positions' pt (my++[p]) a) (zip [1..(arity t)] (args t)))

-- liefert alle Positionen im Term
positions ::  Term -> [Pos]
positions = positions' All []

-- liefert die Positionen aller Funktionssymbole
funPositions :: Term -> [Pos]
funPositions = positions' Fun []

-- liegert die Positionen aller Variablensymbole
varPositions :: Term -> [Pos]
varPositions = positions' Var []

-- Terme zum Testen
v = V (var "x")
f = F (func "s" [v,k,v,k])
k = F (func "k" [])
f2 = F (func "r" [v,f,k,f])

{-
Term> positions f
[[],[1],[2],[3],[4]]
Term> varPositions f
[[1],[3]]
Term> funPositions f
[[],[2],[4]]

Term> funPositions f2
[[],[2],[2,2],[2,4],[3],[4],[4,2],[4,4]]
Term> varPositions f2
[[1],[2,1],[2,3],[4,1],[4,3]]
Term> positions f2
[[],[1],[2],[2,1],[2,2],[2,3],[2,4],[3],[4],[4,1],[4,2],[4,3],[4,4]]

Das stimmt soweit...
-}