module ExampleDemo (Environ,initial,getNext, provideExample, testThis,mkFuncWithArg,searchGoodTree,isMeta)
where
import PGF
import Data.List
import qualified Data.Map as Map
import qualified Data.Set as Set
import Data.Maybe
import System.Random (RandomGen)
type MyType = CId
type ConcType = CId
type MyFunc = CId
type InterInstr = [String]
data FuncWithArg = FuncWithArg
{FuncWithArg -> MyFunc
getName :: MyFunc,
FuncWithArg -> MyFunc
getType :: MyType,
FuncWithArg -> [MyFunc]
getTypeArgs :: [MyType]
}
deriving (Int -> FuncWithArg -> ShowS
[FuncWithArg] -> ShowS
FuncWithArg -> String
(Int -> FuncWithArg -> ShowS)
-> (FuncWithArg -> String)
-> ([FuncWithArg] -> ShowS)
-> Show FuncWithArg
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FuncWithArg] -> ShowS
$cshowList :: [FuncWithArg] -> ShowS
show :: FuncWithArg -> String
$cshow :: FuncWithArg -> String
showsPrec :: Int -> FuncWithArg -> ShowS
$cshowsPrec :: Int -> FuncWithArg -> ShowS
Show,FuncWithArg -> FuncWithArg -> Bool
(FuncWithArg -> FuncWithArg -> Bool)
-> (FuncWithArg -> FuncWithArg -> Bool) -> Eq FuncWithArg
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FuncWithArg -> FuncWithArg -> Bool
$c/= :: FuncWithArg -> FuncWithArg -> Bool
== :: FuncWithArg -> FuncWithArg -> Bool
$c== :: FuncWithArg -> FuncWithArg -> Bool
Eq,Eq FuncWithArg
Eq FuncWithArg
-> (FuncWithArg -> FuncWithArg -> Ordering)
-> (FuncWithArg -> FuncWithArg -> Bool)
-> (FuncWithArg -> FuncWithArg -> Bool)
-> (FuncWithArg -> FuncWithArg -> Bool)
-> (FuncWithArg -> FuncWithArg -> Bool)
-> (FuncWithArg -> FuncWithArg -> FuncWithArg)
-> (FuncWithArg -> FuncWithArg -> FuncWithArg)
-> Ord FuncWithArg
FuncWithArg -> FuncWithArg -> Bool
FuncWithArg -> FuncWithArg -> Ordering
FuncWithArg -> FuncWithArg -> FuncWithArg
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: FuncWithArg -> FuncWithArg -> FuncWithArg
$cmin :: FuncWithArg -> FuncWithArg -> FuncWithArg
max :: FuncWithArg -> FuncWithArg -> FuncWithArg
$cmax :: FuncWithArg -> FuncWithArg -> FuncWithArg
>= :: FuncWithArg -> FuncWithArg -> Bool
$c>= :: FuncWithArg -> FuncWithArg -> Bool
> :: FuncWithArg -> FuncWithArg -> Bool
$c> :: FuncWithArg -> FuncWithArg -> Bool
<= :: FuncWithArg -> FuncWithArg -> Bool
$c<= :: FuncWithArg -> FuncWithArg -> Bool
< :: FuncWithArg -> FuncWithArg -> Bool
$c< :: FuncWithArg -> FuncWithArg -> Bool
compare :: FuncWithArg -> FuncWithArg -> Ordering
$ccompare :: FuncWithArg -> FuncWithArg -> Ordering
$cp1Ord :: Eq FuncWithArg
Ord)
type TypeMap = Map.Map MyType ConcType
type ConcMap = Map.Map MyFunc Expr
data Environ = Env {Environ -> TypeMap
getTypeMap :: TypeMap,
Environ -> ConcMap
getConcMap :: ConcMap,
Environ -> Map MyFunc [FuncWithArg]
getSigs :: Map.Map MyType [FuncWithArg],
Environ -> [FuncWithArg]
getAll :: [FuncWithArg]
}
getNext :: Environ -> Environ -> ([MyFunc],[MyFunc])
getNext :: Environ -> Environ -> ([MyFunc], [MyFunc])
getNext Environ
env Environ
example_env =
let sgs :: Map MyFunc [FuncWithArg]
sgs = Environ -> Map MyFunc [FuncWithArg]
getSigs Environ
env
allfuncs :: [FuncWithArg]
allfuncs = Environ -> [FuncWithArg]
getAll Environ
env
names :: Set MyFunc
names = [MyFunc] -> Set MyFunc
forall a. Ord a => [a] -> Set a
Set.fromList ([MyFunc] -> Set MyFunc) -> [MyFunc] -> Set MyFunc
forall a b. (a -> b) -> a -> b
$ (FuncWithArg -> MyFunc) -> [FuncWithArg] -> [MyFunc]
forall a b. (a -> b) -> [a] -> [b]
map FuncWithArg -> MyFunc
getName ([FuncWithArg] -> [MyFunc]) -> [FuncWithArg] -> [MyFunc]
forall a b. (a -> b) -> a -> b
$ [[FuncWithArg]] -> [FuncWithArg]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[FuncWithArg]] -> [FuncWithArg])
-> [[FuncWithArg]] -> [FuncWithArg]
forall a b. (a -> b) -> a -> b
$ Map MyFunc [FuncWithArg] -> [[FuncWithArg]]
forall k a. Map k a -> [a]
Map.elems Map MyFunc [FuncWithArg]
sgs
exampleable :: [MyFunc]
exampleable = (MyFunc -> Bool) -> [MyFunc] -> [MyFunc]
forall a. (a -> Bool) -> [a] -> [a]
filter (\MyFunc
x -> (Maybe Expr -> Bool
forall a. Maybe a -> Bool
isJust (Maybe Expr -> Bool) -> Maybe Expr -> Bool
forall a b. (a -> b) -> a -> b
$ MyFunc -> Environ -> Maybe Expr
getNameExpr MyFunc
x Environ
env)
Bool -> Bool -> Bool
&&
(Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ MyFunc -> Set MyFunc -> Bool
forall a. Ord a => a -> Set a -> Bool
Set.member MyFunc
x Set MyFunc
names)
) ([MyFunc] -> [MyFunc]) -> [MyFunc] -> [MyFunc]
forall a b. (a -> b) -> a -> b
$ (FuncWithArg -> MyFunc) -> [FuncWithArg] -> [MyFunc]
forall a b. (a -> b) -> [a] -> [b]
map FuncWithArg -> MyFunc
getName [FuncWithArg]
allfuncs
testeable :: [MyFunc]
testeable = (MyFunc -> Bool) -> [MyFunc] -> [MyFunc]
forall a. (a -> Bool) -> [a] -> [a]
filter (\MyFunc
x -> (Maybe Expr -> Bool
forall a. Maybe a -> Bool
isJust (Maybe Expr -> Bool) -> Maybe Expr -> Bool
forall a b. (a -> b) -> a -> b
$ MyFunc -> Environ -> Maybe Expr
getNameExpr MyFunc
x Environ
env )
Bool -> Bool -> Bool
&&
(MyFunc -> Set MyFunc -> Bool
forall a. Ord a => a -> Set a -> Bool
Set.member MyFunc
x Set MyFunc
names)
) ([MyFunc] -> [MyFunc]) -> [MyFunc] -> [MyFunc]
forall a b. (a -> b) -> a -> b
$ (FuncWithArg -> MyFunc) -> [FuncWithArg] -> [MyFunc]
forall a b. (a -> b) -> [a] -> [b]
map FuncWithArg -> MyFunc
getName [FuncWithArg]
allfuncs
in ([MyFunc]
exampleable,[MyFunc]
testeable)
provideExample :: RandomGen gen => gen -> Environ -> MyFunc -> PGF -> PGF -> Language -> Maybe (Expr,String)
provideExample :: gen
-> Environ
-> MyFunc
-> PGF
-> PGF
-> MyFunc
-> Maybe (Expr, String)
provideExample gen
gen Environ
env MyFunc
myfunc PGF
parsePGF PGF
pgfFile MyFunc
lang =
(Expr -> (Expr, String)) -> Maybe Expr -> Maybe (Expr, String)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Expr -> (Expr, String)
giveExample (Maybe Expr -> Maybe (Expr, String))
-> Maybe Expr -> Maybe (Expr, String)
forall a b. (a -> b) -> a -> b
$ MyFunc -> Environ -> Maybe Expr
getNameExpr MyFunc
myfunc Environ
env
where
giveExample :: Expr -> (Expr, String)
giveExample Expr
e_ =
let newexpr :: Expr
newexpr = [Expr] -> Expr
forall a. [a] -> a
head ([Expr] -> Expr) -> [Expr] -> Expr
forall a b. (a -> b) -> a -> b
$ gen -> PGF -> Expr -> Maybe Int -> [Expr]
forall g. RandomGen g => g -> PGF -> Expr -> Maybe Int -> [Expr]
generateRandomFromDepth gen
gen PGF
pgfFile Expr
e_ (Int -> Maybe Int
forall a. a -> Maybe a
Just Int
5)
ty :: MyFunc
ty = FuncWithArg -> MyFunc
getType (FuncWithArg -> MyFunc) -> FuncWithArg -> MyFunc
forall a b. (a -> b) -> a -> b
$ [FuncWithArg] -> FuncWithArg
forall a. [a] -> a
head ([FuncWithArg] -> FuncWithArg) -> [FuncWithArg] -> FuncWithArg
forall a b. (a -> b) -> a -> b
$ (FuncWithArg -> Bool) -> [FuncWithArg] -> [FuncWithArg]
forall a. (a -> Bool) -> [a] -> [a]
filter (\FuncWithArg
x -> FuncWithArg -> MyFunc
getName FuncWithArg
x MyFunc -> MyFunc -> Bool
forall a. Eq a => a -> a -> Bool
== MyFunc
myfunc) ([FuncWithArg] -> [FuncWithArg]) -> [FuncWithArg] -> [FuncWithArg]
forall a b. (a -> b) -> a -> b
$ Environ -> [FuncWithArg]
getAll Environ
env
embeddedExpr :: String
embeddedExpr = String -> (Expr -> String) -> Maybe Expr -> String
forall b a. b -> (a -> b) -> Maybe a -> b
maybe String
"" (\Expr
x -> String
", as in: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ ShowS
q (PGF -> MyFunc -> Expr -> String
linearize PGF
pgfFile MyFunc
lang Expr
x)) ([FuncWithArg] -> ConcMap -> Maybe Expr
embedInStart (Environ -> [FuncWithArg]
getAll Environ
env) ([(MyFunc, Expr)] -> ConcMap
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(MyFunc
ty,Expr
e_)]))
lexpr :: String
lexpr = PGF -> MyFunc -> Expr -> String
linearize PGF
pgfFile MyFunc
lang Expr
newexpr
q :: ShowS
q String
s = String
sqString -> ShowS
forall a. [a] -> [a] -> [a]
++String
sString -> ShowS
forall a. [a] -> [a] -> [a]
++String
sq
sq :: String
sq = String
"\""
in (Expr
newexpr,ShowS
q String
lexpr String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
embeddedExpr)
testThis :: Environ -> MyFunc -> PGF -> Language -> Maybe String
testThis :: Environ -> MyFunc -> PGF -> MyFunc -> Maybe String
testThis Environ
env MyFunc
myfunc PGF
parsePGF MyFunc
lang =
(Expr -> String) -> Maybe Expr -> Maybe String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (PGF -> MyFunc -> Expr -> String
linearize PGF
parsePGF MyFunc
lang (Expr -> String) -> (Expr -> Expr) -> Expr -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Environ -> Expr -> Expr
mapToResource Environ
env (Expr -> Expr) -> (Expr -> Expr) -> Expr -> Expr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Environ -> Expr -> Expr
llin Environ
env) (Maybe Expr -> Maybe String) -> Maybe Expr -> Maybe String
forall a b. (a -> b) -> a -> b
$
MyFunc -> Environ -> Maybe Expr
getNameExpr MyFunc
myfunc Environ
env
llin :: Environ -> Expr -> Expr
llin :: Environ -> Expr -> Expr
llin Environ
env Expr
expr =
let
(MyFunc
id,[Expr]
args) = Maybe (MyFunc, [Expr]) -> (MyFunc, [Expr])
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe (MyFunc, [Expr]) -> (MyFunc, [Expr]))
-> Maybe (MyFunc, [Expr]) -> (MyFunc, [Expr])
forall a b. (a -> b) -> a -> b
$ Expr -> Maybe (MyFunc, [Expr])
unApp Expr
expr
in
if (Expr -> Bool) -> [Expr] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any Expr -> Bool
isMeta [Expr]
args
then let
sigs :: [FuncWithArg]
sigs = [[FuncWithArg]] -> [FuncWithArg]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[FuncWithArg]] -> [FuncWithArg])
-> [[FuncWithArg]] -> [FuncWithArg]
forall a b. (a -> b) -> a -> b
$ Map MyFunc [FuncWithArg] -> [[FuncWithArg]]
forall k a. Map k a -> [a]
Map.elems (Map MyFunc [FuncWithArg] -> [[FuncWithArg]])
-> Map MyFunc [FuncWithArg] -> [[FuncWithArg]]
forall a b. (a -> b) -> a -> b
$ Environ -> Map MyFunc [FuncWithArg]
getSigs Environ
env
tys :: [MyFunc]
tys = [FuncWithArg] -> MyFunc -> [MyFunc]
findExprWhich [FuncWithArg]
sigs MyFunc
id
in Int -> [MyFunc] -> Expr -> Environ -> Expr
replaceConcArg Int
1 [MyFunc]
tys Expr
expr Environ
env
else MyFunc -> [Expr] -> Expr
mkApp MyFunc
id ([Expr] -> Expr) -> [Expr] -> Expr
forall a b. (a -> b) -> a -> b
$ (Expr -> Expr) -> [Expr] -> [Expr]
forall a b. (a -> b) -> [a] -> [b]
map (Environ -> Expr -> Expr
llin Environ
env) [Expr]
args
replaceConcArg :: Int -> [MyType] -> Expr -> Environ -> Expr
replaceConcArg :: Int -> [MyFunc] -> Expr -> Environ -> Expr
replaceConcArg Int
i [] Expr
expr Environ
env = Expr
expr
replaceConcArg Int
i (MyFunc
t:[MyFunc]
ts) Expr
expr Environ
env =
let ss :: [FuncWithArg]
ss = Maybe [FuncWithArg] -> [FuncWithArg]
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe [FuncWithArg] -> [FuncWithArg])
-> Maybe [FuncWithArg] -> [FuncWithArg]
forall a b. (a -> b) -> a -> b
$ MyFunc -> Map MyFunc [FuncWithArg] -> Maybe [FuncWithArg]
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup MyFunc
t (Map MyFunc [FuncWithArg] -> Maybe [FuncWithArg])
-> Map MyFunc [FuncWithArg] -> Maybe [FuncWithArg]
forall a b. (a -> b) -> a -> b
$ Environ -> Map MyFunc [FuncWithArg]
getSigs Environ
env
args :: [FuncWithArg]
args = (FuncWithArg -> Bool) -> [FuncWithArg] -> [FuncWithArg]
forall a. (a -> Bool) -> [a] -> [a]
filter ([MyFunc] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null ([MyFunc] -> Bool)
-> (FuncWithArg -> [MyFunc]) -> FuncWithArg -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FuncWithArg -> [MyFunc]
getTypeArgs) [FuncWithArg]
ss
finArg :: Expr
finArg = if [FuncWithArg] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [FuncWithArg]
args then let l :: FuncWithArg
l = [FuncWithArg] -> FuncWithArg
forall a. [a] -> a
last [FuncWithArg]
ss in Environ -> Expr -> Expr
llin Environ
env (MyFunc -> [Expr] -> Expr
mkApp (FuncWithArg -> MyFunc
getName FuncWithArg
l) [Int -> Expr
mkMeta Int
j | Int
j <- [Int
1..([MyFunc] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length ([MyFunc] -> Int) -> [MyFunc] -> Int
forall a b. (a -> b) -> a -> b
$ FuncWithArg -> [MyFunc]
getTypeArgs FuncWithArg
l)]])
else MyFunc -> [Expr] -> Expr
mkApp (FuncWithArg -> MyFunc
getName (FuncWithArg -> MyFunc) -> FuncWithArg -> MyFunc
forall a b. (a -> b) -> a -> b
$ [FuncWithArg] -> FuncWithArg
forall a. [a] -> a
last [FuncWithArg]
args) []
in
let newe :: Expr
newe = Int -> Expr -> Expr -> Expr
replaceOne Int
i Expr
finArg Expr
expr
in Int -> [MyFunc] -> Expr -> Environ -> Expr
replaceConcArg (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1) [MyFunc]
ts Expr
newe Environ
env
replaceOne :: Int -> Expr -> Expr -> Expr
replaceOne :: Int -> Expr -> Expr -> Expr
replaceOne Int
i Expr
erep Expr
expr =
if Expr -> Bool
isMeta Expr
expr Bool -> Bool -> Bool
&& ((Maybe Int -> Int
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe Int -> Int) -> Maybe Int -> Int
forall a b. (a -> b) -> a -> b
$ Expr -> Maybe Int
unMeta Expr
expr) Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
i)
then Expr
erep
else if Expr -> Bool
isMeta Expr
expr then Expr
expr
else let (MyFunc
id,[Expr]
args) = Maybe (MyFunc, [Expr]) -> (MyFunc, [Expr])
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe (MyFunc, [Expr]) -> (MyFunc, [Expr]))
-> Maybe (MyFunc, [Expr]) -> (MyFunc, [Expr])
forall a b. (a -> b) -> a -> b
$ Expr -> Maybe (MyFunc, [Expr])
unApp Expr
expr
in
MyFunc -> [Expr] -> Expr
mkApp MyFunc
id ([Expr] -> Expr) -> [Expr] -> Expr
forall a b. (a -> b) -> a -> b
$ (Expr -> Expr) -> [Expr] -> [Expr]
forall a b. (a -> b) -> [a] -> [b]
map (Int -> Expr -> Expr -> Expr
replaceOne Int
i Expr
erep) [Expr]
args
findExprWhich :: [FuncWithArg] -> MyFunc -> [MyType]
findExprWhich :: [FuncWithArg] -> MyFunc -> [MyFunc]
findExprWhich [FuncWithArg]
lst MyFunc
f = FuncWithArg -> [MyFunc]
getTypeArgs (FuncWithArg -> [MyFunc]) -> FuncWithArg -> [MyFunc]
forall a b. (a -> b) -> a -> b
$ [FuncWithArg] -> FuncWithArg
forall a. [a] -> a
head ([FuncWithArg] -> FuncWithArg) -> [FuncWithArg] -> FuncWithArg
forall a b. (a -> b) -> a -> b
$ (FuncWithArg -> Bool) -> [FuncWithArg] -> [FuncWithArg]
forall a. (a -> Bool) -> [a] -> [a]
filter (\FuncWithArg
x -> FuncWithArg -> MyFunc
getName FuncWithArg
x MyFunc -> MyFunc -> Bool
forall a. Eq a => a -> a -> Bool
== MyFunc
f) [FuncWithArg]
lst
mapToResource :: Environ -> Expr -> Expr
mapToResource :: Environ -> Expr -> Expr
mapToResource Environ
env Expr
expr =
let (MyFunc
id,[Expr]
args) = (MyFunc, [Expr])
-> ((MyFunc, [Expr]) -> (MyFunc, [Expr]))
-> Maybe (MyFunc, [Expr])
-> (MyFunc, [Expr])
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (String -> (MyFunc, [Expr])
forall a. HasCallStack => String -> a
error (String -> (MyFunc, [Expr])) -> String -> (MyFunc, [Expr])
forall a b. (a -> b) -> a -> b
$ String
"tried to unwrap " String -> ShowS
forall a. [a] -> [a] -> [a]
++ [MyFunc] -> Expr -> String
showExpr [] Expr
expr) (\(MyFunc, [Expr])
x -> (MyFunc, [Expr])
x) (Expr -> Maybe (MyFunc, [Expr])
unApp Expr
expr)
cmap :: ConcMap
cmap = Environ -> ConcMap
getConcMap Environ
env
cexp :: Expr
cexp = Expr -> (Expr -> Expr) -> Maybe Expr -> Expr
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (String -> Expr
forall a. HasCallStack => String -> a
error (String -> Expr) -> String -> Expr
forall a b. (a -> b) -> a -> b
$ String
"didn't find " String -> ShowS
forall a. [a] -> [a] -> [a]
++ MyFunc -> String
showCId MyFunc
id String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" in "String -> ShowS
forall a. [a] -> [a] -> [a]
++ ConcMap -> String
forall a. Show a => a -> String
show ConcMap
cmap) (\Expr
x -> Expr
x) (MyFunc -> ConcMap -> Maybe Expr
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup MyFunc
id ConcMap
cmap)
in
if [Expr] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Expr]
args then Expr
cexp
else let newargs :: [Expr]
newargs = (Expr -> Expr) -> [Expr] -> [Expr]
forall a b. (a -> b) -> [a] -> [b]
map (Environ -> Expr -> Expr
mapToResource Environ
env) [Expr]
args
in Expr -> Int -> [Expr] -> Expr
replaceAllArgs Expr
cexp Int
1 [Expr]
newargs
where
replaceAllArgs :: Expr -> Int -> [Expr] -> Expr
replaceAllArgs Expr
expr Int
i [] = Expr
expr
replaceAllArgs Expr
expr Int
i (Expr
x:[Expr]
xs) = Expr -> Int -> [Expr] -> Expr
replaceAllArgs (Int -> Expr -> Expr -> Expr
replaceOne Int
i Expr
x Expr
expr) (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1) [Expr]
xs
embedInStart :: [FuncWithArg] -> Map.Map MyType Expr -> Maybe Expr
embedInStart :: [FuncWithArg] -> ConcMap -> Maybe Expr
embedInStart [FuncWithArg]
fss ConcMap
cs =
let currset :: [(MyFunc, Expr)]
currset = ConcMap -> [(MyFunc, Expr)]
forall k a. Map k a -> [(k, a)]
Map.toList ConcMap
cs
nextset :: ConcMap
nextset = [(MyFunc, Expr)] -> ConcMap
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList ([(MyFunc, Expr)] -> ConcMap) -> [(MyFunc, Expr)] -> ConcMap
forall a b. (a -> b) -> a -> b
$ [[(MyFunc, Expr)]] -> [(MyFunc, Expr)]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [ if MyFunc -> [MyFunc] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
elem MyFunc
myt (FuncWithArg -> [MyFunc]
getTypeArgs FuncWithArg
farg)
then (MyFunc, Expr) -> FuncWithArg -> [(MyFunc, Expr)]
connectWithArg (MyFunc
myt,Expr
exp) FuncWithArg
farg else []
| (MyFunc
myt,Expr
exp) <- [(MyFunc, Expr)]
currset, FuncWithArg
farg <- [FuncWithArg]
fss]
nextmap :: ConcMap
nextmap = ConcMap -> ConcMap -> ConcMap
forall k a. Ord k => Map k a -> Map k a -> Map k a
Map.union ConcMap
cs ConcMap
nextset
maybeExpr :: Maybe Expr
maybeExpr = MyFunc -> ConcMap -> Maybe Expr
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup MyFunc
startCateg ConcMap
nextset
in if Maybe Expr -> Bool
forall a. Maybe a -> Bool
isNothing Maybe Expr
maybeExpr then
if ConcMap -> Int
forall k a. Map k a -> Int
Map.size ConcMap
nextmap Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== ConcMap -> Int
forall k a. Map k a -> Int
Map.size ConcMap
cs then Maybe Expr
forall a. Maybe a
Nothing
else [FuncWithArg] -> ConcMap -> Maybe Expr
embedInStart [FuncWithArg]
fss ConcMap
nextmap
else Expr -> Maybe Expr
forall (m :: * -> *) a. Monad m => a -> m a
return (Expr -> Maybe Expr) -> Expr -> Maybe Expr
forall a b. (a -> b) -> a -> b
$ Maybe Expr -> Expr
forall a. HasCallStack => Maybe a -> a
fromJust Maybe Expr
maybeExpr
where
connectWithArg :: (MyFunc, Expr) -> FuncWithArg -> [(MyFunc, Expr)]
connectWithArg (MyFunc
myt,Expr
exp) FuncWithArg
farg =
let ind :: Int
ind = [Int] -> Int
forall a. [a] -> a
head ([Int] -> Int) -> [Int] -> Int
forall a b. (a -> b) -> a -> b
$ MyFunc -> [MyFunc] -> [Int]
forall a. Eq a => a -> [a] -> [Int]
elemIndices MyFunc
myt (FuncWithArg -> [MyFunc]
getTypeArgs FuncWithArg
farg)
in [(FuncWithArg -> MyFunc
getType FuncWithArg
farg, MyFunc -> [Expr] -> Expr
mkApp (FuncWithArg -> MyFunc
getName FuncWithArg
farg) ([Expr] -> Expr) -> [Expr] -> Expr
forall a b. (a -> b) -> a -> b
$ [Int -> Expr
mkMeta Int
i | Int
i <- [Int
1..Int
ind]] [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++ [Expr
exp] [Expr] -> [Expr] -> [Expr]
forall a. [a] -> [a] -> [a]
++ [Int -> Expr
mkMeta Int
i | Int
i <- [(Int
ind Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)..(([MyFunc] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length ([MyFunc] -> Int) -> [MyFunc] -> Int
forall a b. (a -> b) -> a -> b
$ FuncWithArg -> [MyFunc]
getTypeArgs FuncWithArg
farg) Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1)]])]
mkSigs :: [FuncWithArg] -> Map.Map MyType [FuncWithArg]
mkSigs :: [FuncWithArg] -> Map MyFunc [FuncWithArg]
mkSigs [FuncWithArg]
fss = ([FuncWithArg] -> [FuncWithArg] -> [FuncWithArg])
-> [(MyFunc, [FuncWithArg])] -> Map MyFunc [FuncWithArg]
forall k a. Ord k => (a -> a -> a) -> [(k, a)] -> Map k a
Map.fromListWith [FuncWithArg] -> [FuncWithArg] -> [FuncWithArg]
forall a. [a] -> [a] -> [a]
(++) ([(MyFunc, [FuncWithArg])] -> Map MyFunc [FuncWithArg])
-> [(MyFunc, [FuncWithArg])] -> Map MyFunc [FuncWithArg]
forall a b. (a -> b) -> a -> b
$ [MyFunc] -> [[FuncWithArg]] -> [(MyFunc, [FuncWithArg])]
forall a b. [a] -> [b] -> [(a, b)]
zip ((FuncWithArg -> MyFunc) -> [FuncWithArg] -> [MyFunc]
forall a b. (a -> b) -> [a] -> [b]
map FuncWithArg -> MyFunc
getType [FuncWithArg]
fss) ((FuncWithArg -> [FuncWithArg]) -> [FuncWithArg] -> [[FuncWithArg]]
forall a b. (a -> b) -> [a] -> [b]
map (\FuncWithArg
x -> [FuncWithArg
x]) [FuncWithArg]
fss)
searchGoodTree :: Environ -> Expr -> [Expr] -> IO (Maybe (Expr,Expr))
searchGoodTree :: Environ -> Expr -> [Expr] -> IO (Maybe (Expr, Expr))
searchGoodTree Environ
env Expr
expr [] = Maybe (Expr, Expr) -> IO (Maybe (Expr, Expr))
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe (Expr, Expr)
forall a. Maybe a
Nothing
searchGoodTree Environ
env Expr
expr (Expr
e:[Expr]
es) =
do Maybe Expr
val <- Expr -> Expr -> Environ -> IO (Maybe Expr)
debugReplaceArgs Expr
expr Expr
e Environ
env
IO (Maybe (Expr, Expr))
-> (Expr -> IO (Maybe (Expr, Expr)))
-> Maybe Expr
-> IO (Maybe (Expr, Expr))
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Environ -> Expr -> [Expr] -> IO (Maybe (Expr, Expr))
searchGoodTree Environ
env Expr
expr [Expr]
es) (\Expr
x -> Maybe (Expr, Expr) -> IO (Maybe (Expr, Expr))
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe (Expr, Expr) -> IO (Maybe (Expr, Expr)))
-> Maybe (Expr, Expr) -> IO (Maybe (Expr, Expr))
forall a b. (a -> b) -> a -> b
$ (Expr, Expr) -> Maybe (Expr, Expr)
forall a. a -> Maybe a
Just (Expr
x,Expr
e)) Maybe Expr
val
getNameExpr :: MyFunc -> Environ -> Maybe Expr
getNameExpr :: MyFunc -> Environ -> Maybe Expr
getNameExpr MyFunc
myfunc Environ
env =
let allfunc :: [FuncWithArg]
allfunc = (FuncWithArg -> Bool) -> [FuncWithArg] -> [FuncWithArg]
forall a. (a -> Bool) -> [a] -> [a]
filter (\FuncWithArg
x -> FuncWithArg -> MyFunc
getName FuncWithArg
x MyFunc -> MyFunc -> Bool
forall a. Eq a => a -> a -> Bool
== MyFunc
myfunc) ([FuncWithArg] -> [FuncWithArg]) -> [FuncWithArg] -> [FuncWithArg]
forall a b. (a -> b) -> a -> b
$ Environ -> [FuncWithArg]
getAll Environ
env
in
if [FuncWithArg] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [FuncWithArg]
allfunc then Maybe Expr
forall a. Maybe a
Nothing
else FuncWithArg -> Environ -> Maybe Expr
getExpr ([FuncWithArg] -> FuncWithArg
forall a. [a] -> a
head [FuncWithArg]
allfunc) Environ
env
getExpr :: FuncWithArg -> Environ -> Maybe Expr
getExpr :: FuncWithArg -> Environ -> Maybe Expr
getExpr FuncWithArg
farg Environ
env =
let tys :: [MyFunc]
tys = FuncWithArg -> [MyFunc]
getTypeArgs FuncWithArg
farg
ctx :: Map MyFunc [FuncWithArg]
ctx = Environ -> Map MyFunc [FuncWithArg]
getSigs Environ
env
lst :: [Maybe Expr]
lst = Map MyFunc [FuncWithArg] -> [MyFunc] -> Int -> [Maybe Expr]
forall a.
Ord a =>
Map a [FuncWithArg] -> [a] -> Int -> [Maybe Expr]
getConcTypes Map MyFunc [FuncWithArg]
ctx [MyFunc]
tys Int
1
in if ((Maybe Expr -> Bool) -> [Maybe Expr] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Maybe Expr -> Bool
forall a. Maybe a -> Bool
isJust [Maybe Expr]
lst) then Expr -> Maybe Expr
forall a. a -> Maybe a
Just (Expr -> Maybe Expr) -> Expr -> Maybe Expr
forall a b. (a -> b) -> a -> b
$ MyFunc -> [Expr] -> Expr
mkApp (FuncWithArg -> MyFunc
getName FuncWithArg
farg) ((Maybe Expr -> Expr) -> [Maybe Expr] -> [Expr]
forall a b. (a -> b) -> [a] -> [b]
map Maybe Expr -> Expr
forall a. HasCallStack => Maybe a -> a
fromJust [Maybe Expr]
lst)
else Maybe Expr
forall a. Maybe a
Nothing
where getConcTypes :: Map a [FuncWithArg] -> [a] -> Int -> [Maybe Expr]
getConcTypes Map a [FuncWithArg]
context [] Int
i = []
getConcTypes Map a [FuncWithArg]
context (a
ty:[a]
types) Int
i =
let pos :: Maybe [FuncWithArg]
pos = a -> Map a [FuncWithArg] -> Maybe [FuncWithArg]
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup a
ty Map a [FuncWithArg]
context
in
if Maybe [FuncWithArg] -> Bool
forall a. Maybe a -> Bool
isNothing Maybe [FuncWithArg]
pos Bool -> Bool -> Bool
|| ([FuncWithArg] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null ([FuncWithArg] -> Bool) -> [FuncWithArg] -> Bool
forall a b. (a -> b) -> a -> b
$ Maybe [FuncWithArg] -> [FuncWithArg]
forall a. HasCallStack => Maybe a -> a
fromJust Maybe [FuncWithArg]
pos) then [Maybe Expr
forall a. Maybe a
Nothing]
else
let mm :: FuncWithArg
mm = [FuncWithArg] -> FuncWithArg
forall a. [a] -> a
last ([FuncWithArg] -> FuncWithArg) -> [FuncWithArg] -> FuncWithArg
forall a b. (a -> b) -> a -> b
$ Maybe [FuncWithArg] -> [FuncWithArg]
forall a. HasCallStack => Maybe a -> a
fromJust Maybe [FuncWithArg]
pos
mmargs :: [MyFunc]
mmargs = FuncWithArg -> [MyFunc]
getTypeArgs FuncWithArg
mm
newi :: Int
newi = Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ [MyFunc] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [MyFunc]
mmargs Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1
lst :: [Maybe Expr]
lst = Map a [FuncWithArg] -> [a] -> Int -> [Maybe Expr]
getConcTypes (a -> [FuncWithArg] -> Map a [FuncWithArg] -> Map a [FuncWithArg]
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert a
ty ([FuncWithArg] -> [FuncWithArg]
forall a. [a] -> [a]
init ([FuncWithArg] -> [FuncWithArg]) -> [FuncWithArg] -> [FuncWithArg]
forall a b. (a -> b) -> a -> b
$ (Maybe [FuncWithArg] -> [FuncWithArg]
forall a. HasCallStack => Maybe a -> a
fromJust Maybe [FuncWithArg]
pos)) Map a [FuncWithArg]
context) [a]
types (Int
newiInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1)
in
if ((Maybe Expr -> Bool) -> [Maybe Expr] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Maybe Expr -> Bool
forall a. Maybe a -> Bool
isJust [Maybe Expr]
lst) then
(Expr -> Maybe Expr
forall a. a -> Maybe a
Just (Expr -> Maybe Expr) -> Expr -> Maybe Expr
forall a b. (a -> b) -> a -> b
$ MyFunc -> [Expr] -> Expr
mkApp (FuncWithArg -> MyFunc
getName FuncWithArg
mm) [Int -> Expr
mkMeta Int
j | Int
j <- [Int
1..([MyFunc] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [MyFunc]
mmargs)]]) Maybe Expr -> [Maybe Expr] -> [Maybe Expr]
forall a. a -> [a] -> [a]
: [Maybe Expr]
lst
else [Maybe Expr
forall a. Maybe a
Nothing]
isGeneralizationOf :: Expr -> Expr -> Bool
isGeneralizationOf :: Expr -> Expr -> Bool
isGeneralizationOf Expr
genExpr Expr
testExpr =
if Expr -> Bool
isMeta Expr
genExpr then Bool
True
else if Expr -> Bool
isMeta Expr
testExpr then Bool
False
else let genUnwrap :: Maybe (MyFunc, [Expr])
genUnwrap = Expr -> Maybe (MyFunc, [Expr])
unApp Expr
genExpr
testUnwrap :: Maybe (MyFunc, [Expr])
testUnwrap = Expr -> Maybe (MyFunc, [Expr])
unApp Expr
testExpr
in if Maybe (MyFunc, [Expr]) -> Bool
forall a. Maybe a -> Bool
isNothing Maybe (MyFunc, [Expr])
genUnwrap Bool -> Bool -> Bool
|| Maybe (MyFunc, [Expr]) -> Bool
forall a. Maybe a -> Bool
isNothing Maybe (MyFunc, [Expr])
testUnwrap then Bool
False
else let (MyFunc
gencid, [Expr]
genargs) = Maybe (MyFunc, [Expr]) -> (MyFunc, [Expr])
forall a. HasCallStack => Maybe a -> a
fromJust Maybe (MyFunc, [Expr])
genUnwrap
(MyFunc
testcid, [Expr]
testargs) = Maybe (MyFunc, [Expr]) -> (MyFunc, [Expr])
forall a. HasCallStack => Maybe a -> a
fromJust Maybe (MyFunc, [Expr])
testUnwrap
in
(MyFunc
gencid MyFunc -> MyFunc -> Bool
forall a. Eq a => a -> a -> Bool
== MyFunc
testcid) Bool -> Bool -> Bool
&& ([Expr] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Expr]
genargs Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== [Expr] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Expr]
testargs)
Bool -> Bool -> Bool
&& ([Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
and [Expr -> Expr -> Bool
isGeneralizationOf Expr
g Expr
t | (Expr
g,Expr
t) <- ([Expr] -> [Expr] -> [(Expr, Expr)]
forall a b. [a] -> [b] -> [(a, b)]
zip [Expr]
genargs [Expr]
testargs)])
debugReplaceArgs :: Expr -> Expr -> Environ -> IO (Maybe Expr)
debugReplaceArgs :: Expr -> Expr -> Environ -> IO (Maybe Expr)
debugReplaceArgs Expr
aexpr Expr
cexpr Environ
env =
if Maybe (MyFunc, [Expr]) -> Bool
forall a. Maybe a -> Bool
isNothing (Maybe (MyFunc, [Expr]) -> Bool) -> Maybe (MyFunc, [Expr]) -> Bool
forall a b. (a -> b) -> a -> b
$ Expr -> Maybe (MyFunc, [Expr])
unApp Expr
aexpr then Maybe Expr -> IO (Maybe Expr)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Expr
forall a. Maybe a
Nothing
else if (Maybe (MyFunc, [Expr]) -> Bool)
-> [Maybe (MyFunc, [Expr])] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any Maybe (MyFunc, [Expr]) -> Bool
forall a. Maybe a -> Bool
isNothing ([Maybe (MyFunc, [Expr])] -> Bool)
-> [Maybe (MyFunc, [Expr])] -> Bool
forall a b. (a -> b) -> a -> b
$ (Expr -> Maybe (MyFunc, [Expr]))
-> [Expr] -> [Maybe (MyFunc, [Expr])]
forall a b. (a -> b) -> [a] -> [b]
map Expr -> Maybe (MyFunc, [Expr])
unApp ([Expr] -> [Maybe (MyFunc, [Expr])])
-> [Expr] -> [Maybe (MyFunc, [Expr])]
forall a b. (a -> b) -> a -> b
$ (MyFunc, [Expr]) -> [Expr]
forall a b. (a, b) -> b
snd ((MyFunc, [Expr]) -> [Expr]) -> (MyFunc, [Expr]) -> [Expr]
forall a b. (a -> b) -> a -> b
$ Maybe (MyFunc, [Expr]) -> (MyFunc, [Expr])
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe (MyFunc, [Expr]) -> (MyFunc, [Expr]))
-> Maybe (MyFunc, [Expr]) -> (MyFunc, [Expr])
forall a b. (a -> b) -> a -> b
$ Expr -> Maybe (MyFunc, [Expr])
unApp Expr
aexpr then Maybe Expr -> IO (Maybe Expr)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Expr
forall a. Maybe a
Nothing
else
let args :: [MyFunc]
args = (Expr -> MyFunc) -> [Expr] -> [MyFunc]
forall a b. (a -> b) -> [a] -> [b]
map ((MyFunc, [Expr]) -> MyFunc
forall a b. (a, b) -> a
fst((MyFunc, [Expr]) -> MyFunc)
-> (Expr -> (MyFunc, [Expr])) -> Expr -> MyFunc
forall b c a. (b -> c) -> (a -> b) -> a -> c
.Maybe (MyFunc, [Expr]) -> (MyFunc, [Expr])
forall a. HasCallStack => Maybe a -> a
fromJust(Maybe (MyFunc, [Expr]) -> (MyFunc, [Expr]))
-> (Expr -> Maybe (MyFunc, [Expr])) -> Expr -> (MyFunc, [Expr])
forall b c a. (b -> c) -> (a -> b) -> a -> c
.Expr -> Maybe (MyFunc, [Expr])
unApp) ([Expr] -> [MyFunc]) -> [Expr] -> [MyFunc]
forall a b. (a -> b) -> a -> b
$ (MyFunc, [Expr]) -> [Expr]
forall a b. (a, b) -> b
snd ((MyFunc, [Expr]) -> [Expr]) -> (MyFunc, [Expr]) -> [Expr]
forall a b. (a -> b) -> a -> b
$ Maybe (MyFunc, [Expr]) -> (MyFunc, [Expr])
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe (MyFunc, [Expr]) -> (MyFunc, [Expr]))
-> Maybe (MyFunc, [Expr]) -> (MyFunc, [Expr])
forall a b. (a -> b) -> a -> b
$ Expr -> Maybe (MyFunc, [Expr])
unApp Expr
aexpr
concExprs :: [Expr]
concExprs = (MyFunc -> Expr) -> [MyFunc] -> [Expr]
forall a b. (a -> b) -> [a] -> [b]
map (\MyFunc
x -> Maybe Expr -> Expr
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe Expr -> Expr) -> Maybe Expr -> Expr
forall a b. (a -> b) -> a -> b
$ MyFunc -> ConcMap -> Maybe Expr
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup MyFunc
x (ConcMap -> Maybe Expr) -> ConcMap -> Maybe Expr
forall a b. (a -> b) -> a -> b
$ Environ -> ConcMap
getConcMap Environ
env) [MyFunc]
args
in Int -> Expr -> [Expr] -> IO (Maybe Expr)
startReplace Int
1 Expr
cexpr [Expr]
concExprs
where
startReplace :: Int -> Expr -> [Expr] -> IO (Maybe Expr)
startReplace Int
i Expr
cex [] = Maybe Expr -> IO (Maybe Expr)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Expr -> IO (Maybe Expr)) -> Maybe Expr -> IO (Maybe Expr)
forall a b. (a -> b) -> a -> b
$ Expr -> Maybe Expr
forall a. a -> Maybe a
Just Expr
cex
startReplace Int
i Expr
cex (Expr
a:[Expr]
as) = do Maybe Expr
val <- Expr -> Int -> Expr -> IO (Maybe Expr)
debugReplaceConc Expr
cex Int
i Expr
a
IO (Maybe Expr)
-> (Expr -> IO (Maybe Expr)) -> Maybe Expr -> IO (Maybe Expr)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (
Maybe Expr -> IO (Maybe Expr)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Expr
forall a. Maybe a
Nothing)
(\Expr
x ->
Int -> Expr -> [Expr] -> IO (Maybe Expr)
startReplace (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1) Expr
x [Expr]
as)
Maybe Expr
val
debugReplaceConc :: Expr -> Int -> Expr -> IO (Maybe Expr)
debugReplaceConc :: Expr -> Int -> Expr -> IO (Maybe Expr)
debugReplaceConc Expr
expr Int
i Expr
e =
let (Expr
newe,Bool
isThere) = Expr -> (Expr, Bool)
searchArg Expr
expr
in if Bool
isThere then Maybe Expr -> IO (Maybe Expr)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Expr -> IO (Maybe Expr)) -> Maybe Expr -> IO (Maybe Expr)
forall a b. (a -> b) -> a -> b
$ Expr -> Maybe Expr
forall a. a -> Maybe a
Just Expr
newe else Maybe Expr -> IO (Maybe Expr)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Expr -> IO (Maybe Expr)) -> Maybe Expr -> IO (Maybe Expr)
forall a b. (a -> b) -> a -> b
$ Maybe Expr
forall a. Maybe a
Nothing
where
searchArg :: Expr -> (Expr, Bool)
searchArg Expr
e_ =
if Expr -> Expr -> Bool
isGeneralizationOf Expr
e Expr
e_ then (Int -> Expr
mkMeta Int
i, Bool
True)
else (Expr, Bool)
-> ((MyFunc, [Expr]) -> (Expr, Bool))
-> Maybe (MyFunc, [Expr])
-> (Expr, Bool)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Expr
e_,Bool
False) (\(MyFunc
cid,[Expr]
args) -> let repargs :: [(Expr, Bool)]
repargs = (Expr -> (Expr, Bool)) -> [Expr] -> [(Expr, Bool)]
forall a b. (a -> b) -> [a] -> [b]
map Expr -> (Expr, Bool)
searchArg [Expr]
args
in (MyFunc -> [Expr] -> Expr
mkApp MyFunc
cid (((Expr, Bool) -> Expr) -> [(Expr, Bool)] -> [Expr]
forall a b. (a -> b) -> [a] -> [b]
map (Expr, Bool) -> Expr
forall a b. (a, b) -> a
fst [(Expr, Bool)]
repargs), [Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
or ([Bool] -> Bool) -> [Bool] -> Bool
forall a b. (a -> b) -> a -> b
$ ((Expr, Bool) -> Bool) -> [(Expr, Bool)] -> [Bool]
forall a b. (a -> b) -> [a] -> [b]
map (Expr, Bool) -> Bool
forall a b. (a, b) -> b
snd [(Expr, Bool)]
repargs)) (Maybe (MyFunc, [Expr]) -> (Expr, Bool))
-> Maybe (MyFunc, [Expr]) -> (Expr, Bool)
forall a b. (a -> b) -> a -> b
$ Expr -> Maybe (MyFunc, [Expr])
unApp Expr
e_
isMeta :: Expr -> Bool
isMeta :: Expr -> Bool
isMeta = Maybe Int -> Bool
forall a. Maybe a -> Bool
isJust(Maybe Int -> Bool) -> (Expr -> Maybe Int) -> Expr -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
.Expr -> Maybe Int
unMeta
mkFuncWithArg :: ((CId,CId),[CId]) -> FuncWithArg
mkFuncWithArg :: ((MyFunc, MyFunc), [MyFunc]) -> FuncWithArg
mkFuncWithArg ((MyFunc
c1,MyFunc
c2),[MyFunc]
cids) = MyFunc -> MyFunc -> [MyFunc] -> FuncWithArg
FuncWithArg MyFunc
c1 MyFunc
c2 [MyFunc]
cids
initial :: TypeMap -> ConcMap -> [FuncWithArg] -> [FuncWithArg] -> Environ
initial :: TypeMap -> ConcMap -> [FuncWithArg] -> [FuncWithArg] -> Environ
initial TypeMap
tm ConcMap
cm [FuncWithArg]
fss [FuncWithArg]
allfs = TypeMap
-> ConcMap -> Map MyFunc [FuncWithArg] -> [FuncWithArg] -> Environ
Env TypeMap
tm ConcMap
cm ([FuncWithArg] -> Map MyFunc [FuncWithArg]
mkSigs [FuncWithArg]
fss) [FuncWithArg]
allfs
startCateg :: MyFunc
startCateg = String -> MyFunc
mkCId String
"Comment"