Switched from Tokens to IRIs for NeSy identifier

NeSyPatterns/AS.der.hs

@@ -21,6 +21,7 @@ Definition of abstract syntax for neural-symbolic patterns
 
 module NeSyPatterns.AS where
 
+import Common.IRI
 import Common.Id as Id
 import Common.Doc
 import Common.DocUtils
@@ -35,8 +36,8 @@ import Data.Data
 -- | nodes are of form: id : ontology_term
 -- | id is optional
 data Node = Node {
-    ontologyTerm :: Id.Token,
-    nesyId :: (Maybe Id.Token),
+    ontologyTerm :: IRI,
+    nesyId :: (Maybe IRI),
     nodeRange :: Id.Range
   } deriving (Show, Typeable, Data, Eq, Ord)
 newtype BASIC_SPEC = Basic_spec { items :: [AS_Anno.Annoted BASIC_ITEM] }
@@ -48,7 +49,7 @@ data BASIC_ITEM = Path {
     deriving (Show, Typeable, Data)
 
 
-newtype SYMB = Symb_id Id.Token
+newtype SYMB = Symb_id IRI
             deriving (Show, Eq, Ord, Typeable, Data)
 
 data SYMB_ITEMS = Symb_items [SYMB] Id.Range

NeSyPatterns/Analysis.hs

@@ -34,7 +34,7 @@ import Data.Maybe (catMaybes)
 import Data.Foldable (foldrM, foldlM)
 import NeSyPatterns.Sign as Sign
 
-import Common.IRI (IRI)
+import Common.IRI
 
 import qualified Common.AS_Annotation as AS_Anno
 import qualified Common.GlobalAnnotations as GlobalAnnos
@@ -56,15 +56,15 @@ makeSig ::
 makeSig bs sig = let spec' = genIds bs in
   foldrM retrieveBasicItem sig spec'
 
-addNodeToIdMap :: AS.Node -> Map.Map Id.Token Id.Token -> Map.Map Id.Token Id.Token
+addNodeToIdMap :: AS.Node -> Map.Map IRI IRI -> Map.Map IRI IRI
 addNodeToIdMap (AS.Node o mi _) m = case mi of
   Just i -> Map.insert i o m
   Nothing -> m
 
-addPathToIdMap :: AS.BASIC_ITEM -> Map.Map Id.Token Id.Token -> Map.Map Id.Token Id.Token
+addPathToIdMap :: AS.BASIC_ITEM -> Map.Map IRI IRI -> Map.Map IRI IRI
 addPathToIdMap (AS.Path ns) m = foldr addNodeToIdMap m ns
 
-extractIdMap :: AS.BASIC_SPEC -> Map.Map Id.Token Id.Token
+extractIdMap :: AS.BASIC_SPEC -> Map.Map IRI IRI
 extractIdMap (AS.Basic_spec spec) = foldr addPathToIdMap Map.empty (AS_Anno.item <$> spec)
 
 genIds :: AS.BASIC_SPEC -> [AS.BASIC_ITEM]
@@ -75,7 +75,7 @@ genIdsPath (AS.Path ns) (genId, agg) = ((: agg) . AS.Path <$> foldr genIdsNode (
 
 genIdsNode :: AS.Node -> (Int, [AS.Node]) -> (Int, [AS.Node])
 genIdsNode node (genId, agg) = case AS.nesyId node of
-  Nothing -> (genId + 1, node { AS.nesyId = Just $ Id.mkNumVar "__genid" genId } : agg)
+  Nothing -> (genId + 1, node { AS.nesyId = Just $ idToIRI $ Id.mkId [ Id.genNumVar "nesy" genId ] } : agg)
   _ -> (genId, node : agg)
 
 
@@ -214,8 +214,8 @@ computeGLB r s =
                     _ -> Nothing 
 
 allLabels :: [(Int, Set.Set ResolvedNode)] -- the graph nodes
-          -> Map.Map Int (Map.Map Id.Token Id.Token) -- the structural morphisms f of the colimit on nodeIds
-          -> Id.Token -- the nodeId N in the colimit 
+          -> Map.Map Int (Map.Map IRI IRI) -- the structural morphisms f of the colimit on nodeIds
+          -> IRI -- the nodeId N in the colimit 
           -> Set.Set ResolvedNode 
           -- all resolved nodes in the graph whose nodeId is mapped to N 
           -- along the corresponding morphism in f
@@ -235,11 +235,11 @@ signatureColimit graph = do
                Gr.emap (\ (x, m) -> (x, Morphism.morphism2TokenMap m)) graph
       (nodeSet, maps) = addIntToSymbols $ computeColimitSet graph1
   resSet <- foldlM (\aSet aNode -> do
-                        let labSet = Set.map (tokToIRI . Sign.resolvedOTerm) $ 
+                        let labSet = Set.map Sign.resolvedOTerm $ 
                                      allLabels (map (\(i, s) -> (i, Sign.nodes s)) $ Gr.labNodes graph) maps aNode
                         case computeGLB owlR labSet of
                           Nothing -> fail "couldn't compute greatest lower bound" 
-                          Just glb -> return $ Set.insert (ResolvedNode (uriToTok glb) aNode Id.nullRange) aSet    
+                          Just glb -> return $ Set.insert (ResolvedNode glb aNode Id.nullRange) aSet    
                      ) Set.empty nodeSet
   nMaps <- foldlM (\f (i, sig) -> do
                     let fi = Map.findWithDefault (error "missing morphism") i maps

NeSyPatterns/Morphism.hs

@@ -58,15 +58,15 @@ idMor :: Sign -> Morphism
 idMor a = inclusionMap a a
 
 -- | convert to token map
-morphism2TokenMap :: Morphism -> Map.Map Token Token
+morphism2TokenMap :: Morphism -> Map.Map IRI IRI
 morphism2TokenMap m = 
  foldl (\aMap (x, fx) -> Map.insert x fx aMap) Map.empty $ 
  map (\(x, fx) -> (resolvedNeSyId x, resolvedNeSyId fx)) $ 
  Map.toList $ nodeMap m
 
 tokenMap2NodeMap ::  Set.Set ResolvedNode
                   -> Set.Set ResolvedNode
-                  -> Map.Map Token Token
+                  -> Map.Map IRI IRI
                   -> Result (Map.Map ResolvedNode ResolvedNode)
 tokenMap2NodeMap sSet tSet tMap =
  foldM (\f (t1, t2) -> do

NeSyPatterns/Parse.hs

@@ -54,16 +54,14 @@ uriP = try $ do
     if not (isAbbrev q) || startsWithColon then True
     else not (null p) || (iFragment q) `notElem` nesyKeywords
 
-name :: GA.PrefixMap -> AParser st Token
-name pm = wrapAnnos $ do
-    iri <- expUriP pm
-    return (mkSimpleId (show iri)) { tokPos = iriPos iri}
+name :: GA.PrefixMap -> AParser st IRI
+name pm = wrapAnnos $ expUriP pm
 
 node :: GA.PrefixMap -> AParser st Node
 node pm = do
     n <- name pm
     classM <- optionMaybe (asKey ":" >> name pm)
-    let range = catRange . catMaybes $ [Just n, classM]
+    let range = getRange . catMaybes $ [Just n, classM]
     return $ case classM of
         Nothing -> Node n Nothing range
         Just ot -> Node ot (Just n) range

NeSyPatterns/Sign.hs

@@ -15,7 +15,6 @@ Definition of signatures for neural-symbolic patterns
 module NeSyPatterns.Sign
     (Sign (..)                      -- Signatures6
     , ResolvedNode(..)
-    , id2SimpleId
     , resolved2Node
     , findNodeId
     , nesyIdMap
@@ -50,13 +49,13 @@ import NeSyPatterns.Print()
 
 
 data ResolvedNode = ResolvedNode {
-    resolvedOTerm :: Token,
-    resolvedNeSyId :: Token,
+    resolvedOTerm :: IRI,
+    resolvedNeSyId :: IRI,
     resolvedNodeRange :: Range
   } deriving (Show, Eq, Ord, Typeable, Data)
 
 instance SymbolName ResolvedNode where
-  addString (ResolvedNode t1 t2 r, s) = ResolvedNode t1 (addStringToTok t2 s) r
+  addString (ResolvedNode t1 t2 r, s) = ResolvedNode t1 (addSuffixToIRI s t2) r
 
 instance Pretty ResolvedNode where
   pretty (ResolvedNode o i r) = pretty $ Node o (Just i) r
@@ -72,28 +71,24 @@ data Sign = Sign { owlClasses :: Set.Set IRI,
                    owlTaxonomy :: Rel.Relation IRI IRI,
                    nodes :: Set.Set ResolvedNode,
                    edges :: Rel.Relation ResolvedNode ResolvedNode,
-                   idMap :: Map.Map Token Token }
+                   idMap :: Map.Map IRI IRI }
   deriving (Show, Eq, Ord, Typeable)
 
 instance Pretty Sign where
     pretty = printSign
 
-findNodeId :: Token -> Set.Set ResolvedNode -> Set.Set ResolvedNode
+findNodeId :: IRI -> Set.Set ResolvedNode -> Set.Set ResolvedNode
 findNodeId t s = Set.filter (\(ResolvedNode _ t1 _) -> t == t1 ) s  
 
-nesyIds :: Sign -> Set.Set Token
+nesyIds :: Sign -> Set.Set IRI
 nesyIds = Set.map resolvedNeSyId . nodes
 
-nesyIdMap :: Set.Set ResolvedNode -> Map.Map Token Token
+nesyIdMap :: Set.Set ResolvedNode -> Map.Map IRI IRI
 nesyIdMap nodes = Map.fromList [(i, o) | ResolvedNode o i _ <- Set.toList nodes]
 
 resolved2Node :: ResolvedNode -> Node
 resolved2Node (ResolvedNode t i r) = Node t (Just i) r
 
-id2SimpleId :: Id -> Token
-id2SimpleId i = case filter (not . isPlace) $ getTokens i of
-  [] -> error "id2SimpleId"
-  c : _ -> c
 
 {- | determines whether a signature is vaild -}
 isLegalSignature :: Sign -> Bool

NeSyPatterns/Symbol.hs

@@ -26,6 +26,7 @@ module NeSyPatterns.Symbol
     , applySymMap          -- application function for symbol maps
     ) where
 
+import Common.IRI
 import qualified Common.Id as Id
 import Common.Doc
 import Common.DocUtils
@@ -67,12 +68,14 @@ getSymbolMap f =
 
 -- | Determines the name of a symbol
 getSymbolName :: Symbol -> Id.Id
-getSymbolName (Symbol ( AS.Node o i _)) = Id.mkId $ catMaybes [Just o, i]
+getSymbolName (Symbol ( AS.Node o i _)) = Id.appendId (uriToCaslId o) (maybe (Id.mkId []) uriToCaslId i)
 
 -- | make a raw_symbol
 idToRaw :: Id.Id -> Symbol
 idToRaw mid = case Id.getPlainTokenList mid of
-  [o, i] -> Symbol $ AS.Node o (Just i) (Id.posOfId mid)
+  [o, i] -> case (parseIRI $ show o, parseIRI $ show i) of 
+      (Just o', Just i') -> Symbol $ AS.Node o' (Just i') (Id.posOfId mid)
+      _ -> error "NeSyPatterns.Symbol.idToRaw: Invalid iri"
   _ -> error "NeSyPatterns.Symbol.idToRaw: Invalid number of tokens"
 
 -- | convert to raw symbol