Question

I recently finished a project in which I was generating lists of strings, and I was wondering about the best way to do this.

The string generation was context sensitive to determine if it was acceptable(it was a sequence of plays in a game, so you had to know what the last play was)

The way I did it was with a function that was passed the context parameter and the term, and if it was acceptable it recursively continued, if it wasn’t it terminated(since no further string could be acceptable.) The function also received a “length” parameter to make sure it terminated eventually

basically this is generating every possible string accepted by a language(of a certain length).

Now, I got this to work, even fairly well and cleanly, but I was wondering if there were a better way to do this. Specifically, would a “state machine” monad work well in generating a context sensitive grammar? or something similar at least? The problem seems to simple to want to fire up something like parsec, are there other structures that are effective in manipulating languages?

Any thoughts would be appreciated.

Answer 1

I thought this problem looked interesting, so I tried a few different ways of implementing it. The code below is the approach the seemed most promising. I think it solves the problem as described, although I was unsure of some details.

Basically it allows a form of context sensitive grammars, but only a quite simple form where each production can only depend on the previous symbol. The code below builds up some combinators that allow the productions to be coded very directly as “generators”, and that take care of the length limit behind the scene.

type sym = Xa | Xb | Xc          // The terminal symbols 
type word = sym list             // A string of terminals

type gen = int -> sym list seq   // Generate words up to the given length

/// Passes the previous symbol to a generator, after checking the length.
let (+>) : sym  -> (sym -> gen) -> gen = 
    fun x g l -> if l<=0 then Seq.empty 
                         else seq { for xs in g x (l-1) -> x :: xs }

let nil _ = seq { yield [] }                    // Generate just the empty word            
let (|||) xs ys l = Seq.append (xs l) (ys l)    // Union of two generators
let notAccepted _ = Seq.empty                   // Don't generate anything

let tryAll g = Xa +> g ||| Xb +> g ||| Xc +> g  // Run g starting with any sym

// Generators for non-terminals.  Each takes the previous symbol as an argument,
// and generates a (possibly empty) sequence of lists of symbols.
let rec gR = function Xa ->  Xb +> gS ||| Xc +> gR  ||| nil  
                    | Xc ->  Xb +> gS                        | _ -> notAccepted
    and gS = function Xb ->  Xa +> gR                        | _ -> notAccepted


let genTop = tryAll gR  // The top level generator begins with gR with any sym

let words = genTop 4    // Generate words up to length 4
// val words : seq<sym list> 
//           = seq [[Xa; Xb; Xa]; [Xa; Xc; Xb; Xa]; [Xa]; [Xc; Xb; Xa]]