[racket] Use of map and eval to evaluate symbol in namespace

On Aug 3, 2014, at 3:29 PM, Henry Lenzi <henry.lenzi at gmail.com> wrote:

> ; Hello all --
> ; So here's how I solve all those little problems regarding symbols
> and evaluation of medication definitions.
> ; Would you please bear with me? I apologize for the length.
> ; This is the approach I've taken. I've chosen no to use any macrology
> or parser/lexer technique because I don't grok them and they
> ; don't really seem necessary, for reasons explained in the code comments.
> ; I have not decided to hash tables, for the following reason: there's
> a part of the code (the drug definitions, the instructions), that
> ; should be easy enough for non-programmers to edit. If they are kept
> very simple, it's possible, because the users have to edit those
> ; files. So, even though it is source code, it's not as intimidating
> as editing source code if hash tables.
> ; Another aspect is that I hope modules provided some sort of safety
> in terms of syntax checking. That is to say, if you used make a
> ; typo in the medication part of the DSL, the system will (hopefully)
> bork because no such module exists. I believe this also creates
> ; an opportunity for "syntax validation" if a proper input phase is
> designed. But Lisp/Scheme being a dynamic language, the run-time
> ; will bork immediately once it sees funny things. This is a way to
> guarantee the DSL is correct, which we get for free by using Racket.
> ; A fourth aspect is that, if each drug is kept a different module
> (which I haven't done here, BTW), then we can make for easier
> ; internationalization, by keeping modules by languages, e.g.,
> hctz25-en, hctz25-pt_br. I believe Dan has an interest in this project
> too,
> ; so  it's best to design with that in mind.
> ; Final comment regards "database". We get "database" for free, by
> registering prescriptions with patient register numbers. The OS
> ; takes care of pretty musch anything else. And there's no need for
> atomicity and concurrency. Like I said, this is stupid code.
> ;
> ;
> #lang racket
> 
> ; code-review-for-racketeers-2014-08-03-a.rkt
> ;
> ; For this exercise, suppose a Recipe.txt file. Let´s suppose the idea
> is that the physician
> ; has two options: 1) he or she opens Notepad and writes the
> prescription file (Recipe.text);
> ; 2) or, the software asks for inputs and writes the file (this will
> not be covered in this
> ; exercise). The written prescription in the shorthand DSL would look
> like below, with the
> ; exception of a first field with patient ID data not included (to be
> done later).
> ; The prescription has a rigid syntax would look like this (line
> breaks included):
> ; 1-
> ; hctz25 30 pl 1xd
> ;
> ; 2-
> ; simva20 30 pl 1xn
> 
> 
> ; Needed for EVAL, used later on
> (define-namespace-anchor a)
> 
> ; These definitions should be in a different module.
> ; This way we get syntax checking for free.
> ; MED - medication. Includes dosage.
> (define hctz25 "Hydrochlorothiazide 25mg")
> (define simva20 "Simvastatin 20mg")
> ; FORM - whether the patient will take home pills, a tube, a flask, capsules
> (define pl "pills")
> ; POS - posology, whether the patient will take 1 pill 3x a day, or 2
> pills 2x a day, etc.
> (define 1xd "Take 1 pill P.O. 1x/day")
> (define 1xn "Take 1 pill P.O. 1x at night")
> ; INSTs - special instructions. INST is just a prefix INST+MED without
> the dosage.
> (define INSTOMZ "half an hour before breakfast, with a glass of water")
> ; Formatters - simple for now, but should be a function of the space available.
> (define  line "-----------")
> 
> 
> 
> ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
> ; The main part of a prescription DSL is pretty rigid in syntax, being
> composed of blocks of theses parts:
> ; MEDICATION QUANTITY FORM POSOLOGY INSTRUCTION, or MED QUANT FORM POS INST.
> ; Please note that, in this DSL, the MED part includes the drug dosage
> (e.g., HCTZ25, where
> ; the HCTZ designates the drug, and the 25 the dosage).
> ; An example would be:
> ; HCTZ25 30 PL 1XD
> ; meaning: Hydrochlorothiazide 25mg -------------- 30 pills
> ;                Take 1 pill P.O. 1X day
> ; INST are special instructions. They basically are more detailed
> explanation to the patient about
> ; how to use the medication properly. Not always there's a INST in the
> prescription DSL.
> ; INSTs are, in fact, a PREFIX for the MED without the dose. For
> example, OMZ20 is Omeprazol 20mg.
> ; The instruction for OMZ would be INSTOMZ ("half an hour before
> breakfast, with a glass of water").
> ; In this case, the DSL line would be:
> ; OMZ20 30 PL 1XD INSTOMZ
> ; meaning: Omeprazol 20mg ------------------- 30 pills
> ;               Take 1 pill P.O. 1X day
> ;               half an hour before breakfast, with
> ;               a glass of water
> ; Questions regarding proper formatting of INST are not addressed at
> this moment.
> ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
> ; Now follows a description of some problems I encountered and the
> choices made in solving them:
> ; (define in (open-input-file "Recipe.txt"))
> ; If you just (string-split (read-line in)) you'll get:
> ; => '("hctz25" "30" "cp" "1xd")
> ; and that will not evaluate the symbols to their string descritptions.
> ; Because of that, you need to do a:
> ; > (map string->symbol (string-split (read-line in)))
> ; which will evaluate to
> ; => '(hctz25 |30| cp 1xd)
> ; This would be ideal to MAP EVAL to, but the problem is the |30|

What you want here is something like this:
;; Instead of (map string->symbol (string-split (read-line in)))
(for/list ([thing (in-port read in)]) thing)
;; and then you can do (map eval …) to that if you want.
;; Or you could do both at once like this:
(for/list ([thing (in-port read in)])
  (eval thing namespace))

> ; So, the idea is SET!ing that list to a name we can call easily, i.e.,
> ; med-line-holder, because then we can extract the pieces (since we
> can't do list
> ; surgery easily, such a "replace the the element at position 1 with
> so-and-so element").
> ; Since the prescription syntax is pretty rigid, we can get away with this
> ; simple approach.
> 
> (define med-line-holder '()) ; initial value of med-line-holder is an empty list
> (define med-name-holder '())
> (define med-quant-holder '())
> (define med-form-holder '())
> (define med-pos-holder '())
> (define med-inst-holder '()) ; remember, not always INSTructions
> happen in a DSL prescription .
> 
> (define in (open-input-file "Recipe.txt"))
> (port-count-lines! in)
> (define (clpr) (close-input-port in))
> 
> ; a med-line-holder is a list that has MED QUANT FORM POS (and sometimes INST)
> ; This is obtained from a plain text file. When it is read, it becomes something
> ; like this: '(hctz25 |30| cp 1xd)
> (define (set-med-line-holder)
>  (set! med-line-holder (map string->symbol (string-split (read-line in)))))
> 
> (define (set-med-name-holder)
>   ; (set! med-name-holder (eval (car med-line-holder))) ;; in the REPL
>  (set! med-name-holder (eval (car med-line-holder)
> (namespace-anchor->namespace a))))
> 
> (define (set-med-quant-holder) ; the CADR of the med-line-holder
>  ; (set! med-quant-holder (eval (symbol->string (cadr med-line-holder))))
>  (set! med-quant-holder (eval (symbol->string (cadr med-line-holder))
> (namespace-anchor->namespace a))))
> 
> (define (set-med-form-holder) ; the CADDR of the med-line-holder -
> gets the FORM, e.g., pills, etc.
>  ; (set! med-form-holder (eval (symbol->string (caddr med-line-holder))))
>  (set! med-form-holder (eval (caddr med-line-holder)
> (namespace-anchor->namespace a))))
> 
> (define (set-med-pos-holder) ; the CADDDR of the med-line-holder -
> gets the POS, e.g., 1xd
>    ; (set! med-pos-holder (eval (symbol->string (cadddr med-line-holder))))
>  (set! med-pos-holder (eval (cadddr med-line-holder)
> (namespace-anchor->namespace a))))
> 
> 
> (define (set-med-inst-holder) ; the LAST of the med-line-holder - gets the INST
>    ; (set! med-pos-holder (eval (symbol->string (last med-line-holder))))
>  (set! med-pos-holder (eval (last med-line-holder)
> (namespace-anchor->namespace a))))
> 
> ; One problem here regards the optional INST instructions.
> ; How to create a SETter function that will only SET! med-inst-holder
> ; if there's an INST instruction? Note that INST is a prefix. A real
> instruction is, e.g.,
> ; INSTOMZ (for OMZ20).
> (define (look-for-line)
>  (if (regexp-match #px"\\d\\-" (read-line in))
>      (begin
>        (set-med-line-holder)
>        (set-med-name-holder)
>        (set-med-quant-holder)
>        (set-med-form-holder)
>        (set-med-pos-holder))
>      'NO-LINE))
> 
> (define (display-stuff)
>  (newline)
>  (display med-line-holder) (newline)
>  (display med-name-holder) (newline)
>  (display med-quant-holder) (newline)
>  (display med-form-holder) (newline)
>  (display med-pos-holder) (newline))
> ; The problem remains of what to do with the eventual INST.
> 
> 
> ; Successive calls to (look-for-line) would read the next lines.
> ; Output would alternate between a DSL line, or a NO-LINE (from look-for-line,
> ; if it hits a line with no text in Recipe.txt
> (look-for-line)
> ;(display-stuff)
> 
> 
> (define (output-a-line)
> (string-join (list med-name-holder line med-quant-holder med-form-holder "\n"
>                             med-pos-holder "\n")))
> 
> (define (format-a-line)
>  (display (output-a-line)))
> 
> ;(define (output-a-line)
> ; (display (string-join (list med-name-holder line med-quant-holder
> med-form-holder "\n"
> ;                             med-pos-holder "\n"))))
> (newline)
> ;(output-a-line)
> 
> (format-a-line)
> 
> 
> 
> ; PROBLEMS
> ; 1) How do we find out how many lines to (look-for-line)?
> ;    This is one of the resons I specified the "1-", "2-" in the Recipe.txt. Not
> ;    only it makes for easy visual understanding, but it may be used
> to provide a hint
> ;    for this problem.
> ;    Possible approaches:
> ;    - Maybe this can be solved with REGEXPS? This information could
> provide a sentinel
> ;      variable for an iterator function?
> ;    - Is there some sort if line counting function? (Note that I have set
> ;      (port-count-lines! in) somewhere above in the code.
> ; 2) How do we know we've reached the end of the file?
> ; 3) How to deal with the not-always-present INST?
> ;    - How do we check for INSTs? With a REGEXP?
> ;    - Choosing between INSTs with REGEXPS is not necessary, as they
> will be loaded in a module,
> ;      so the system will "know" which one to choose.
> ; 4) Another idea would be "slurp" the whole of the prescription, and
> then deal with evaluation. How?
> ; (define f1
> ;    (file->string
> ;   "C:\\Path\\to\\sources\\Recipe.txt"))
> ;> (string-normalize-spaces f1)
> ;"1- hctz25 30 pl 1xd 2- simva20 30 pl 1xn"
> ;
> ; That's all for now, folks!
> ; Many thanks for all the help so far, Racketeers!
> ; Cheers,
> ; Henry Lenzi
> 
> 
> 
> 
> On Sat, Aug 2, 2014 at 12:44 AM, Henry Lenzi <henry.lenzi at gmail.com> wrote:
>> Hello everyone -
>> 
>> First of all, a big Thank You to all of you and for taking the time for
>> responding.
>> 
>> I'll have to set aside sometime during this weekend to see if I can
>> understand the ideas you've been so kind to offer.
>> 
>> However, I should confess that I've made some progress with way simpler
>> stuff which I hope to post later on.  Like I've said, this is stupid
>> software. Anyways, none of this is final.
>> 
>> It really just used a plain text solution, since the format if a recipe is
>> so rigid. The question of expanding the symbols from files to run-time was
>> easier than I thought.
>> 
>> The idea of using modules might have the nice collateral effect if some sort
>> of primitive type (or syntax) checking for free. I like the idea someone
>> offered of using modules for medication definitions. Actually, one module
>> per definition makes it very easy for future users to add new medications.
>> The ease of syntax is important because it allows for the customization by
>> non-sophisticated users (physicians, nurses).
>> 
>> Cheers,
>> Henry Lenzi.
> 
> ____________________
>  Racket Users list:
>  http://lists.racket-lang.org/users