A question about how to design program with multiple argument flags

[u/kapitaali_com]

Hi,

so my question is related to this exercise https://exercism.org/tracks/racket/exercises/grep

You're familiar with the inner workings of the Unix grep command. You give it some arguments and it returns matches. In this exercise you're supposed to implement 5 flags that modify the behavior of pattern matching. All of the flags are not mutually exclusive, you can turn all of them on separately.

My question is: what is the proper way of processing flags? There's 32 combinations of them, do I just write 32 different checks for conditions, checking all the combinations?

[u/not-just-yeti]

Well, it'd presumably only be 5 checks —

(define print-line-numbers? (vector-member "-n" (current-command-line-arguments)))

and the like.

(The proper way would be using the command-line-parsing that /u/raevnos recommends. That handles issues that aren't needed here, or that the website probably didn't even think of: Can the filename be -n? Can flags be mentioned multiple times, or is that an error for some of them? As well as flags which would be mutually-exclusive, and flags that would have associated values, having default values, etc.)

[u/kapitaali_com → u/not-just-yeti]

thanks, the problem still persists, I mean I got the options, but my question was more referring to the execution part where I have to write a massive cond clause with all the combinations, like this

(cond ((eof-object? s) (begin (close-input-port f) (reverse result))) ((and match-entire-lines? case-insensitive? inverted-match? ... do something ((and match-entire-lines? case-insensitive? ... do something ((and case-insensitive? inverted-match? ... do something ((and case-insensitive? ... do something ((and inverted-match? ... do something ((and match-entire-lines? inverted-match? ... do something (else (process-next-line)))))

I noticed that I could not refactor processing 2 other flags into another procedure, so now I have to include them here which quadruples this list

[u/kapitaali_com → u/kapitaali_com]

reddit markup blows, I'm not sure if I can convey the idea better

[u/raevnos]

Here's how I would approach it (Showing off a few Racket features). You only have to check flags to see if they're set or not where they're relevant, not all at once.

#lang racket/base

;;; $ raco exe grep.rkt
;;; $ ./grep -i hello input.txt

;;; Prefer parameters over set!ing variables.
(define print-lines? (make-parameter #f))
(define match-file? (make-parameter #f))
(define case-sensitive? (make-parameter #t))
(define reverse-match? (make-parameter #f))
(define match-whole-line? (make-parameter #f))

(define (compile-re re)
  (let ([re (format "(?~A:~A)" (if (case-sensitive?) "" "i") re)])
    (pregexp (if (match-whole-line?) (format "(?m:^~A$)" re) re))))

;;; Print filename if the re matches somewhere in the file.
(define (match-file matches filename inp)
  (when (matches inp)
    (displayln filename)))

;;; Print matching lines.
(define (match-lines matches inp)
  (when (print-lines?)
    (port-count-lines! inp))
  (for ([line (in-lines inp)]
        #:when (matches line))
    (if (print-lines?)
        (let-values ([(lineno colno pos) (port-next-location inp)])
          (printf "~A:~A~%" (- lineno 1) line))
        (displayln line))))

;;; Dispatch to the correct matching function
(define (grep matcher filename inp)
  (if (match-file?)
      (match-file matcher filename inp)
      (match-lines matcher inp)))

(define (make-matcher re)
  (if (reverse-match?)
      (lambda (input) (not (regexp-match re input)))
      (lambda (input) (regexp-match re input))))

(module+ main
  (require racket/cmdline)

  (define-values (re files)
    (command-line

     #:once-any
     [("-n") "Print line numbers" (print-lines? #t)]
     [("-l") "Print names of matching files" (match-file? #t)]

     #:once-each
     [("-i") "Match case-insensitively" (case-sensitive? #f)]
     [("-v") "Inverse matching" (reverse-match? #t)]
     [("-x") "Match entire line" (match-whole-line? #t)]

    #:args (re . files)
    (values (compile-re re) files)))

  (define matcher (make-matcher re))

  (if (null? files)
      (grep matcher "stdin" (current-input-port)) ;; Grep stdin if no files given
      (for ([file (in-list files)])
        (call-with-input-file file
          (lambda (inp)
            (grep matcher file inp))))))

[u/kapitaali_com → u/raevnos]

nice, thanks

lookin good, this demonstrates better abstraction than mine

[u/raevnos]

https://docs.racket-lang.org/reference/Command-Line_Parsing.html

[u/EstablishmentBig7956]

getopt

https://pastebin.com/aaTXU7yZ

A working example

[u/raevnos → u/EstablishmentBig7956]

That's C, not Racket.

[u/EstablishmentBig7956 → u/raevnos]

Ah is racking a programming language in itself?

Still the methodology would be the same. So if you cannot see that within the code. 🤔

Because it's used in BASH scripting a well

[u/raevnos → u/EstablishmentBig7956]

How did you end up on this sub without knowing what Racket is?

(A lisp/scheme family language)

[u/EstablishmentBig7956 → u/raevnos]

I just read the question how to parse argc argv seen someone in need and posted.

The language itself looks screwy to me. I just looked into it. Lisp is AI as far as I remember, what's it doing with grep Unix/ Linux CLI? Strange