minor parser improvements. allow > as output prefix.

Author: mengwong

README.md

@@ -117,6 +117,8 @@ Supported. This is the native format for `dmnmd`.
 
 ASCII has its limitations. In graphical decision tables, output columns are separated from input columns by a double bar; most GUI implementations use colour and other formatting to distinguish input, output, and annotation columns. In `dmnmd` syntax, output columns are optionally labeled with an `(out)`; annotation columns are prefixed with a `#`. By default, if the columns are unlabeled, the rightmost column will be taken to be the output, and columns to the left will be taken to be inputs. (Leaving out annotation columns.)
 
+You can also prefix output columns with a `>` character.
+
 Columns are optionally typed using a colon. You will see `Column Name : String`, `Column Name : Number`, and `Column Name : Boolean`. If you omit the type definition, `dmnmd` will attempt to infer the type.
 
 In some decision tables, the input and outputs are enumerated in a sort of sub-header row. The order matters.
@@ -131,7 +133,7 @@ For hit policy "O", the order of results in the output is determined by the orde
 
 The column enums are giving in a subhead row between the top row and body data row "1".
 
-| O | Age | Risk Category     | Debt Review :Boolean | Routing (out)          | Review level (out)     | Reason (out)                |
+| O | Age | Risk Category     | Debt Review :Boolean | > Routing              | > Review level         | Reason (out)                |
 |---|-----|-------------------|----------------------|------------------------|------------------------|-----------------------------|
 |   |     | LOW, MEDIUM, HIGH |                      | DECLINE, REFER, ACCEPT | LEVEL 2, LEVEL 1, NONE |                             |
 | 1 | -   | -                 | -                    | ACCEPT                 | NONE                   | Acceptable                  |

languages/haskell/src/DMN/ParseFEEL.hs

@@ -7,6 +7,7 @@ import Control.Applicative hiding (many, some)
 import Text.Megaparsec
 import Text.Megaparsec.Char
 import Data.Text (Text)
+import Data.Char (isAlphaNum)
 import qualified Data.Text as T
 import DMN.Types
 import DMN.ParsingUtils
@@ -17,11 +18,15 @@ import Debug.Trace
 -- let's allow spaces in variable names. what could possibly go wrong?
 parseVarname :: Parser Text
 parseVarname = do
-  input <- T.take 40 <$> lookAhead takeRest
-  -- traceM $ "parseVarname: input: " ++ T.unpack input
+  -- input <- T.take 40 <$> lookAhead takeRest; traceM $ "parseVarname: input: " ++ T.unpack input
   firstLetter <- letterChar
-  remainder <- some (choice [ alphaNumChar, char '_', char ' ' ])
-  return $ T.strip $ T.append (T.singleton firstLetter) (T.pack remainder)
+  remainder <- takeWhileP (Just "legal identifier character, including spaces")
+               (\c -> isAlphaNum c    || c == '\t'
+                      || c == ' '     || c == '\x00A0' -- nonbreaking space
+                      || c == '_'     || c == '_'      )
+
+  -- we should now have run up against either eol, |, (, or :
+  return $ T.strip $ T.cons firstLetter remainder
 
 
 parseFNumFunction :: Parser FNumFunction

languages/haskell/src/DMN/ParseTable.hs

@@ -48,40 +48,50 @@ pipeSeparator = try $ Mega.label "pipeSeparator" $ skipHorizontalSpace >> "|" >
 getpipeSeparator :: Parser Text
 getpipeSeparator = skipHorizontalSpace *> "|" <* skipHorizontalSpace
 
+-- | parse column header.
+-- (//|#|>|<) *([a-zA-Z0-9_ ]+?( *: *[a-z]+) *
 parseColHeader :: Parser ColHeader
 parseColHeader = do
-  mylabel_pre <- parseLabelPre <* skipHorizontalSpace <?> "mylabel_pre"
-  myvarname <- parseVarname <?> "parseVarname"
+  mylabel_pre  <- parseLabelPre <?> "pre-label"
+  myvarname    <- parseVarname <?> "variable name"
   doTrace $ "parseColHeader: done with parseVarname, got: \"" ++ T.unpack myvarname ++ "\""
-  mytype <- parseTypeDecl <?> "parseTypeDecl"
-  mylabel_post <- skipHorizontalSpace *> parseLabelPost <?> "parseLabelPost"
-  return $ DTCH (mkHeaderLabel mylabel_pre mylabel_post) (T.unpack myvarname) mytype Nothing
+  mytype       <- parseTypeDecl <?> "type declaration"
+  mylabel_post <- skipHorizontalSpace *> parseLabelPost <?> "post-label (in/out/comment)"
+  return ( DTCH
+           (mkHeaderLabel mylabel_pre mylabel_post)
+           (T.unpack myvarname)
+           mytype Nothing )
 
-parseTypeDecl :: Parser (Maybe DMNType) -- Nothing means it's up to some later code to infer the type. Usually it gets treated just like a String.
-parseTypeDecl = Mega.optional $ do
-  skipHorizontalSpace >> ":" >> skipHorizontalSpace
-  parseType
+-- | Nothing means it's up to some later code to infer the type. Usually it gets treated just like a String.
+parseTypeDecl :: Parser (Maybe DMNType)
+parseTypeDecl = Mega.optional $ lexeme ":" *> parseType
 
-parseType :: Parser DMNType
-parseType =
-  DMN_List <$> ("[" *> parseType <* "]" <?> "inside list")
-   <|>
-   ((("String"  >> return (DMN_String)) <?> "string type") <|>
-    (("Number"  >> return (DMN_Number)) <?> "number type") <|>
-    (("Boolean" >> return (DMN_Boolean)) <?> "boolean type") ) -- need to check what the official DMN names are for these
+lexeme :: Parser a -> Parser a
+lexeme x = x <* skipHorizontalSpace
 
+parseType :: Parser DMNType
+parseType
+  =   (DMN_List    <$>  (lexeme "[" *> parseType <* lexeme "]") <?> "inside list")
+  <|> (DMN_String  <$    lexeme "String"                        <?> "string type")
+  <|> (DMN_Number  <$    lexeme "Number"                        <?> "number type")
+  <|> (DMN_Boolean <$    lexeme "Boolean"                       <?> "boolean type")
+  -- need to check what the official DMN names are for these
+    
+mkHeaderLabel :: Maybe Text -> Maybe Text -> DTCH_Label
 mkHeaderLabel (Just "//") _        = DTCH_Comment
 mkHeaderLabel (Just "#" ) _        = DTCH_Comment
+mkHeaderLabel (Just "<" ) _        = DTCH_In
+mkHeaderLabel (Just ">" ) _        = DTCH_Out
 mkHeaderLabel _ (Just "(comment)") = DTCH_Comment
 mkHeaderLabel _ (Just "(out)")     = DTCH_Out
 mkHeaderLabel _ (Just "(in)")      = DTCH_In
 mkHeaderLabel _  Nothing           = DTCH_In
 
 parseLabelPre :: Parser (Maybe Text)
-parseLabelPre  = Mega.optional ("//"   <|> "#")
+parseLabelPre  = Mega.optional $ lexeme ("//" <|> "#" <|> "<" <|> ">")
 
 parseLabelPost :: Parser (Maybe Text)
-parseLabelPost = Mega.optional ("(in)" <|> "(out)" <|> "(comment)")
+parseLabelPost = Mega.optional $ lexeme ("(in)" <|> "(out)" <|> "(comment)")
 
 parseHitPolicy :: Parser HitPolicy
 parseHitPolicy =