此无上下文语言枚举器的伪代码实现是什么？

Question

This blog post in Haskell explains how context-free grammars can be enumerated with aid of a monad called Omega.

I could not understand how this works partly due to the lack of an explanation on how that monad works, but mostly due to the fact I can't understand monads. What is a proper pseudo-code explanation of that algorithm, without monads ?

Using a syntax similar to a simple, common language such as JavaScript or Python would be preferred.

Answer 1

Here's a Haskell version without the monad. I do use list comprehensions but those are more intuitive and you have them in Python as well.

The Omega type is just a wrapper around [] , but it helps to keep the "string of symbols" and the "list of possible strings" concepts separate. Since we're not going to use Omega for "list of possible strings", let's use a newtype wrapper for "string of symbols" to keep everything straight:

import Prelude hiding (String)

-- represent a sequence of symbols of type `a`,
-- i.e. a string recognised by a grammar over `a`
newtype String a = String [a]
    deriving Show

-- simple wrapper for (++) to also make things more explicit when we use it
joinStrings (String a1) (String a2) = String (a1 ++ a2)

Here's the Symbol type from the blogpost:

data Symbol a
    = Terminal a
    | Nonterminal [[Symbol a]] -- a disjunction of juxtapositions

The core of the Omega monad is actually the diagonal function:

-- | This is the hinge algorithm of the Omega monad,
-- exposed because it can be useful on its own.  Joins 
-- a list of lists with the property that for every x y 
-- there is an n such that @xs !! x !! y == diagonal xs !! n@.
diagonal :: [[a]] -> [a]

Given this, enumerate from the blogpost was:

enumerate :: Symbol a -> Omega [a]
enumerate (Terminal a) = return [a]
enumerate (Nonterminal alts) = do
    alt <- each alts          -- for each alternative
      -- (each is the Omega constructor :: [a] -> Omega a)
    rep <- mapM enumerate alt -- enumerate each symbol in the sequence
    return $ concat rep       -- and concatenate the results

Our enumerate will have this type:

enumerate :: Symbol a -> [String a]

The Terminal case is easy:

enumerate (Terminal a) = [String [a]]

In the Nonterminal case a helper function for each alternative will be useful:

-- Enumerate the strings accepted by a sequence of symbols
enumerateSymbols :: [Symbol a] -> [String a]

The base case is quite easy, though the result isn't [] , but a singleton result containing the empty string:

enumerateSymbols [] = [String []]

For the non-empty case another helper will be useful to pair up the strings from the head and from the tail in all possible ways, using diagonal :

crossProduct :: [a] -> [b] -> [(a, b)]
crossProduct as bs = diagonal [[(a, b) | b <- bs] | a <- as]

I could also have written [[(a, b) | a <- as] | b <- bs] [[(a, b) | a <- as] | b <- bs] [[(a, b) | a <- as] | b <- bs] but I chose the other because that ends up replicating the output from the blogpost.

Now we can write the non-empty case for enumerateSymbols :

enumerateSymbols (sym:syms) =
    let prefixes = enumerate sym
        suffixes = enumerateSymbols syms
    in [joinStrings prefix suffix 
           | (prefix, suffix) <- crossProduct prefixes suffixes]

and now the non-empty case for enumerate :

enumerate (Nonterminal alts) =
    -- get the list of strings for each of the alternatives
    let choices = map enumerateSymbols alts
    -- and use diagonal to combine them in a "fair" way
    in diagonal choices

Here's the body of diagonal from the Omega source, with my explanations:

diagonal = diagonal' 0
    where

    -- strip n xss returns two lists,
    -- the first containing the head of each of the first n lists in xss,
    -- the second containing the tail of the first n lists in xss
    -- and all of the remaining lists in xss.
    -- empty lists in xss are ignored
    stripe 0 xss          = ([],xss)
    stripe n []           = ([],[])
    stripe n ([]:xss)     = stripe n xss
    stripe n ((x:xs):xss) = 
        let (nstripe, nlists) = stripe (n-1) xss
        in (x:nstripe, xs:nlists)


    -- diagonal' n xss uses stripe n to split up
    -- xss into a chunk of n elements representing the
    -- nth diagonal of the original input, and the rest
    -- of the original input for a recursive call to
    -- diagonal' (n+1)

    diagonal' _ [] = []
    diagonal' n xss =
        let (str, xss') = stripe n xss
        in str ++ diagonal' (n+1) xss'

It's also worth reading this paper about the general concept of diagonalization and breadth-first search of an infinite structure.