shrughes

Here’s the code:

(define (in-forum-thread-descriptions forum-number)
  (let ([chain (list capture-text
                     'spacer
                     (both (is-tag #"a")
                           (has-class #"thread_title")
                           (has-attr-match #"href" #px#"showthread\\.php\\?threadid=(\\d+)")))]
        [combiners (list text-combiner car)])
    (in-match-and-combine chain combiners (get-forum-html-stacks forum-number))))

And here’s the result:

> (for ([desc (in-forum-thread-descriptions 202)])
    (printf "~a: ~a\n" (cadr desc) (car desc)))
2779598: Ask General Programming Questions Not Worth Their Own Thread
2836504: Cavern of Cobol FAQ (Read this first)
3048157: iPhone Development Megathread
3161913: WordPress - Development, Themes, Plugins.
2672629: SELECT * FROM Questions WHERE Type = 'Stupid'
2773485: C/C++ Programming Questions Not Worth Their Own Thread
3286714: "Run As Administrator" on Win2008 getting in the way of SQL SSIS jobs?
3263809: Another How Much Money Should I Be Making Thread
3283309: Ada Lovelace Day
2841382: Post screenshots of stuff you're working on!
2675400: Python information and short questions megathread.
2802621: <?PHP questions that don\\'t need their own thread ?>
3246449: Goons for Hire: Get your Developers here
3286440: Powershell
2803713: Coding horrors: post the code that makes you laugh (or cry)
3070034: Javascript questions which don't deserve their own thread.
2692947: Game Development Megathread
2262300: .Net Questions Megathread Part 2
2790475: Django Web Framework: The 'D' is silent dumbass
2718078: Web Design/Development Small Questions - Rev Holy Grail
3286273: Planning/Building Family Websites: What's this family tree doing in my web?
2780384: Java questions which don't deserve their own thread, yet.
3108969: a Vim thread
2662688: Xcode and Cocoa Megathread
2664804: The Perl Short Questions Megathread: executable line noise
3281048: When to (and not to) use goto;
2897255: 3D graphics questions that do not deserve their own thread (OpenGL / Dx10)
3113983: Version Control Questions Megathread (SVN / git / whatever else)
2585949: Ruby on Rails Love-In
2385157: Flash Questions Megathread

I don’t really know much about PLT Scheme sequences, but they seem to be fairly warty. First of all, consuming a sequence may destroy the sequence (at least if you use in-generator to make one). This is annoying, but I suppose it could also be regarded as a dangerous feature. Also, there’s no easy way (as far as I can tell) to convert sequences to lists. All I can find is

(for/list ([x seq])
  x)

Generators are pretty nice, and in-generator is okay, you can make sequences like this:

(define (in-filter pred seq)
  (in-generator (for ([x seq])
                  (when (pred x)
                    (yield x)))))

Right now, if you try to enumerate a sequence defined by uses of in-generator that have side-effects, you end up eating the sequence, so that subsequent enumerations nonchalantly tell you that the sequence has no elements. I’ll have to make a version of in-generator that throws an exception on subsequent enumerations. Here’s a function that would benefit:

(define (in-matches pattern port)
  (in-generator (let loop ()
                  (let ([matches (regexp-match pattern port)])
                    (when matches
                      (yield matches)
                      (loop))))))

This function consumes the port. It either needs to use (in-memo (in-generator ...)) or it needs to use in-destructive, which would be the exception-throwing generator I would have to implement.

Here’s my implementation of in-memo, for what it’s worth.

;;; Makes a memoized version of the sequence, which you can iterate
;;; through without destroying the sequence.
(define (in-memo seq)
  (let-values ([(has-next? next!) (sequence-generate)])
    (letrec ([next-node (λ () (if (has-next?)
                                (cons (next!) (delay (next-node)))
                                '()))])
      (let ([stream-head (delay (next-node))])
        (in-generator (let loop ([forced-stream (force stream-head)])
                        (when (not (null? forced-stream))
                          (yield (car forced-stream))
                          (loop (force (cdr forced-stream))))))))))

I don’t know, that seems fairly ugly.

--------------------------------
Side discussion below this point
--------------------------------

Sometimes I get annoyed by Scheme’s lack of laziness. I’m used to Haskell’s laziness, you see. For example, you can’t implement Data.Function.on in Scheme — not in the same way — because something like ((&&) `on` f) wouldn’t short-circuit. I wanted short-circuiting behavior, and the only way to do it was to define a macro…

(define-syntax-rule (on binary-op f) (λ (x y) (binary-op (f x) (f y))))

This is much uglier. Scheme is generally uglier, but more comely, than Haskell.

I made some slight adjustments to the HTML Parsing.

> (define txt (string-append "<!DOCTYPE HTML><html lang=\"en\"><head><title>"
                             "Hello</title>  </head><body>text</body></html>"))
> (map (λ (stack) (matches-predicate-chain stack (list 'spacer (both (is-tag "html")
                                                                     (has-attr-value "lang" "en")))))
       (get-html-stacks (get-html-segments txt)))
(#f #t #t #t #t #t #t #t #t #t #t #f)
> (map (λ (stack) (matches-predicate-chain stack (list 'spacer (both (is-tag "html")
                                                                     (has-attr-value "lang" "foo")))))
       (get-html-stacks (get-html-segments txt)))
(#f #f #f #f #f #f #f #f #f #f #f #f)

Now attributes can be reasoned with. And the parser now generates stacks with top nodes on the top — with text nodes on top, and so on.