StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

POParsing: Lazy initialization and mutually recursive monads in F#
primarykey
Id
1084374
data
AcceptedAnswerId
1084555
AnswerCount
3
ClosedDate
CommentCount
0
CommunityOwnedDate
CreationDate
2009-07-05T16:31:56.897
FavoriteCount
3
LastActivityDate
2010-11-25T10:51:49.807
LastEditDate
LastEditorUserId
0
OwnerUserId
105459
ParentId
0
PostTypeId
1
Score
3
ViewCount
828
LastEditorDisplayName
text
Body
I've been writing a little monadic parser-combinator library in F# (somewhat similar to <a href="http://www.quanttec.com/fparsec/" rel="nofollow noreferrer">FParsec</a>) and now tried to implement a small parser for a programming language. I first implemented the code in Haskell (with Parsec) which ran perfectly well. The parsers for infix expressions are designed mutually recursive. <pre><code>parseInfixOp :: Parser String -> Parser Expression -> Parser Expression parseInfixOp operatorParser subParser = ignoreSpaces $ do x <- ignoreSpaces $ subParser do op <- ignoreSpaces $ operatorParser y <- parseInfixOp operatorParser subParser return $ BinaryOp op x y <|> return x parseInfix :: [String] -> Parser Expression -> Parser Expression parseInfix list = parseInfixOp (foldl1 (<|>) $ map string list) parseExpr :: Parser Expression parseExpr = parseInfix0 parseInfix0 = parseInfix ["==", "<>", "And", "Or", "Xor", "<", ">", "<=", ">="] parseInfix1 parseInfix1 = parseInfix ["+", "-", "Mod"] parseInfix2 parseInfix2 = parseInfix ["*", "/", "\\"] parseInfix3 parseInfix3 = parseInfix ["^"] parseInfix4 parseInfix4 = parseFactor parseFactor :: Parser Expression parseFactor = parseFactor' <|> (betweenChars '(' ')' parseExpr) parseFactor' :: Parser Expression parseFactor' = parseString <|> parseBool <|> parseNumber <|> parseVariable <|> (try parseFunCall) <|> parseIdentifier </code></pre> Since the order of functions doesn't matter and Haskell is evaluating in a non-strict way, this is OK, but F# is evaluating strictly. <pre><code>let rec parseExpr = parseInfix0 and parseFactor = (parseFactor') <|> (betweenChars '(' ')' parseExpr) and parseInfix2 = parseInfix ["^"] parseFactor BinaryOp and parseInfix1 = parseInfix ["*"; "/"] parseInfix2 BinaryOp and parseInfix0 = parseInfix ["+"; "-"] parseInfix1 BinaryOp and parseFunCall = parser { let! first = letter let! rest = many (letter <|> digit) let funcName = toStr $ first::rest do! ignoreSpace let! args = betweenChars '(' ')' $ sepBy (parseExpr) "," return FunCall(funcName, args) } and parseFactor' = parseNumber <|> parseString <|> parseBool <|> parseFunCall <|> parseIdentifier </code></pre> F# now either complains about recursive objects and just throws a <code>StackOverflowException</code> at runtime due to an infinite loop or it even doesn't compile the source because "a value would be part of its own definion". What's the best way to prevent this errors. The debugger advices me to make use functions or <code>lazy</code>s instead but what should I make lazy here? 
Tags
<parsing><f#><recursion><lazy-evaluation>
Title
Parsing: Lazy initialization and mutually recursive monads in F#
singulars
PostAcceptedAnswerId
1. PO
 singulars
 PostTypePostTypeId
 PTAnswer
PostParentId
1. This table or related slice is empty.
PostTypePostTypeId
1. PTQuestion
UserLastEditorUserId
1. This table or related slice is empty.
UserOwnerUserId
1. USDario
plurals
PostLinksPostIdRelatedPostId
1. This table or related slice is empty.
PostLinksRelatedPostIdPostId
1. This table or related slice is empty.
PostsAcceptedAnswerId
1. This table or related slice is empty.
PostsParentIdCreationDate
1. PO
 singulars
 PostTypePostTypeId
 PTAnswer
2. PO
 singulars
 PostTypePostTypeId
 PTAnswer
3. PO
 singulars
 PostTypePostTypeId
 PTAnswer
VotesPostIdCreationDate
1. VO
 singulars
 PostPostId
 POParsing: Lazy initialization and mutually recursive monads in F#
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
2. VO
 singulars
 PostPostId
 POParsing: Lazy initialization and mutually recursive monads in F#
 UserUserId
 USharms
 VoteTypeVoteTypeId
 VTFavorite
3. VO
 singulars
 PostPostId
 POParsing: Lazy initialization and mutually recursive monads in F#
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
CommentsPostId
1. This table or related slice is empty.

Querying!

Guidance

A row detail

Detail views are divided into sections. All the information in the data section comes from columns in the selected row. The other sections display data from other, related rows.

Related data can be related in a to-one or a to-many fashion. Captions of data related in a to-many fashion link to a list view showing a filtered view of the table.

Try moving around until you find a non-empty to-many entry and click on the label to get to one. You can move back to the root by clicking on the database name in the header.