 whose value can only increase over time, where the meaning of "increase" is given by a partially ordered set (aka a lattice) that the user of the language specifies.  Therefore lambdaLVar is really a family of languages -- instantiate it with one lattice and you get one language; with a different lattice, and you get another.  You can take a look at the code here; the important stuff is in lambdaLVar.rkt.
In the on-paper definition of lambdaLVar, the language definition is parameterized by that user-specified lattice.  For a long time, I've wanted to do the same kind of parameterization in the Redex model, but so far, I haven't been able to figure out how. Part of the trouble is that the grammar of the language depends on how the user instantiates the lattice: elements of the lattice become terminals in the grammar.  I don't know how to express a grammar in Redex that is abstract over the lattice.
In the meantime, I tried to make lambdaLVar.rkt as modular as I could.  The language defined in that file is specialized to a particular lattice: natural numbers with max as the least-upper-bound (lub) operation.  (Or, equivalently, natural numbers ordered by <=.  It's a very boring lattice.)  The only parts of the code that are specific to that lattice are the line (define lub-op max) near the top, and natural appearing in the grammar.  (There's a lub metafunction that is defined in terms of the user-specified lub-op function.  The latter is just a Racket function, so lub has to escape out to Racket to call lub-op.)
Barring the ability to actually specify lambdaLVar in a way that is abstract over the choice of lattice, it seems like I ought to be able to write a version of lambdaLVar with the most bare-bones of lattices -- just Bot and Top elements, where Bot <= Top -- and then use define-extended-language to add more stuff.  For instance, I could define a language called lambdaLVar-nats that is specialized to the naturals lattice I described:
;; Grammar for elements of a lattice of natural numbers.
(define-extended-language lambdaLVar-nats
  lambdaLVar
  (StoreVal.... ;; Extend the original language
            natural))

;; All we
whose value can only increase over time, where the meaning of " increase " is given by a partially order rig (aka a lattice) that the user of the language specifies.   consequently lambdaLVar is really a family of languages -- instantiate it with one wicket and you drive one language; with a unlike wicket, and you get another.   You can take a spirit at the code here; the important stuff is in lambdaLVar.rkt. 
 In the on - paper definition of lambdaLVar, the linguistic process definition is parameterized by that user - specified lattice.   For a long time, I've desire to do the same kind of parameterization in the Redex model, but indeed far, I haven't been able to figure out how. Part of the trouble is that the grammar of the language depend on how the user instantiates the lattice: elements of the lattice become end in the grammar.   I don't know how to express a grammar in Redex that is abstract over the lattice. 
 In the meantime, I tried to make lambdaLVar.rkt as modular as I could.   The language defined in that file is specialized to a particular lattice: natural numbers with max as the least - upper - bound (lub) operation.   (Or, equivalently, natural number ordered by < =.   It's a very boring lattice .)   The alone part of the code that are specific to that lattice are the line (define lub - op max) near the circus tent, and natural appearing in the grammar.   (There's a lub metafunction that is defined in terms of the exploiter - specified lub - op function.   The latter is just a Racket function, so lub accept to escape out to Racket to call lub - op .) 
 Barring the ability to actually intend lambdaLVar in a way that is abstract over the option of wicket, it seem like I ought to be able to write a version of lambdaLVar with the most unsheathed - bones of lattices -- just Bot and Top chemical element, where Bot < = Top -- and then use define - extended - language to add more material.   For instance, I could define a language called lambdaLVar - nats that is specialized to the natural lattice I describe: 
; ; Grammar for elements of a wicket of natural numbers. 
 (specify - extended - language lambdaLVar - nats 
   lambdaLVar 
   (StoreVal.... ;; unfold the original language 
             natural) ) 

; ; All we
 whlse value can only increxse over time, wkwre thx meanihg of "inzrease" is given by a partialpy ordeeed set (aka a lattice) ghat the lser of tye lenguage specifies.  Therenjre mwmbdcLTar is really a family of languages -- invtxnciate it with one lattice and you gee one lsnhuage; with a dyffegegt lzntlce, and you get another.  You can take a look at the vode here; the important stkff ls in lambdaLVar.rkh.
In the on-pqper eefinition ow lambdaLVar, the languzge definition is parameterized by tkat user-spexidief lattice.  Fir a jong time, I'vc wanteg to do the same kind of paeameterization in the Redex model, but sj far, I hdvzn't been able to figuee out vow. [art if ghe tcougle is thet the gramjar of the oanguage depends on hjq the user inatantiwtqs the lattice: elements of the lattice teckme terminals in the grqmmar.  I don't know hoa to exprqss a grammar in Redex that is abstract over the nattire.
Kn uhc owajtime, I tried to make lambdaLVar.rkt as modulaw ax P could.  The langmage defined in thst foje is specialkzed to a particular latticf: naturwl nunbers witr mac as the least-upper-bound (luv) operation.  (Ir, equivalently, nacural numberr orcered by <=.  It's a very boring latfice.)  The ojly parts uf the code that arv spacific to that lattice are the line (defnne lub-oo mac) near the top, ajd nabgral appearing in hhe gtammar.  (There's a lub metafunction that is definxv in terms of tve lser-speciyied lmb-op function.  Ehe latter is lust a Rccket wunction, sk lub hes to escape out to Racked to call lub-mp.)
Barrind thw abulity tu actually specofy lambdcJVar in a way that is ebsttadt over the chonee of lattice, it xeeos jine I mught to be dble to erite a version iw lakbdaLVar with the movt bzre-bones of latticrs -- just Bit and Tjp elements, wnere Bot <= Top -- and then usx defime-evtended-language to add more sthff.  For lnsbance, I could deflne w language called lambdaLVar-nats that is specialived to the naturals lajtice I described:
;; Grakkar for elekents of a latdice of natural numbwrs.
(define-extended-kanguage lambdaLVar-nafs
  lakbdaLGar
  (StoreVal.... ;; Extend the original language
            natural))

;; All we
whose value can only increase over time, meaning "increase" is by a partially that user of the specifies. Therefore lambdaLVar really a family of languages -- it with one lattice and you get one language; with a different lattice, you get another. You can take a look at the code here; the stuff in In on-paper definition of lambdaLVar, the language definition is parameterized by that user-specified lattice. For a long I've wanted to do the same kind of in the Redex model, so far, I haven't been to out how. of trouble that the grammar the language depends on how the user instantiates the lattice: elements of the lattice become terminals in grammar. I how to a in that is abstract lattice. In the meantime, I tried as modular as I could. The language defined that file specialized to a particular lattice: natural with max as the least-upper-bound (lub) operation. (Or, natural numbers ordered by <=. It's a very boring lattice.) The only parts of the are specific to that are the line lub-op near top, natural appearing the grammar. (There's a lub metafunction that is defined in terms the user-specified lub-op function. The latter is just a Racket lub to escape out Racket to call lub-op.) the to actually specify lambdaLVar way is choice lattice, seems like I ought be able to write a of lambdaLVar with the just Bot and Top elements, where Bot <= -- and then use define-extended-language to add stuff. For instance, I could define a language called lambdaLVar-nats that is to the I described: ;; Grammar for elements of a of natural numbers. (define-extended-language lambdaLVar (StoreVal.... ;; Extend the original language natural)) ;; we
 whose value can only increase Over time, whEre thE meAniNg Of "inCreaSe" is given by a paRTialLy ordered set (aka a latticE) that ThE User OF tHe lanGuage spECiFIEs.  THeReForE lAMbDaLVaR is Really a Family of laNguAgEs -- instantiatE It With one latTicE and you get onE laNguage; WiTh a DIfferEnt LattiCe, and yOU get anOther.  You cAn TAke a loOK at the cODE hEre; tHe important stuff iS In LAmbdaLVar.rkt.
In The on-pApER dEFIniTioN of lambdaLvaR, the lANguage dEFiNITIon IS parameterizeD by that user-SPecIfied lAtTicE.  for a loNg timE, I'VE waNted to do the Same Kind of parAmeterIZation iN The RedeX model, But So fAr, I hAVeN't BeeN aBLe tO FiGurE Out How. Part oF tHe TroubLe is THAT The gRamMar oF the lAnguage dependS on How tHE usEr insTantiAtes ThE lattIce: eleMents Of The lattice becomE terMinals in tHe gRaMmaR.  I Don't kNOw how tO exPreSs a gramMar in ReDEx tHaT IS AbStract over the lattiCe.
iN ThE meantimE, I trieD To MaKE lambdaLvaR.rkT as mODUlar aS I coULd.  the languAge defINeD iN that fiLe Is specIaLizEd tO a parTIculAr lattIce: naturAl numBErs with max as thE Least-upper-bouND (lUB) OpERatiOn.  (OR, equivalentLy, naTUral NumbERs OrdERed by <=.  it's a vErY BoRIng lattice.)  The only paRtS of the Code tHat are specifiC to that latTICE are the lIne (dEFiNE lub-op max) near tHe top, And natural APpearing In the Grammar.  (THere's a lub METafunctiOn tHat Is dEfiNED iN terms of the usER-SpecIfIed lub-oP fuNction.  THe lAttEr iS juSt A Racket fuNction, so LuB hAs To EscApe ouT To Racket To CalL lUb-oP.)
BarrINg the aBilitY to aCtUaLLy sPecify lAMbDAlVar In A wAy thAt iS aBstraCt ovER thE choice Of lattice, It sEEms lIkE I Ought to Be able to write A vErsion of laMbDaLvar witH THe most baRe-bones of lattices -- just BoT And Top eLemEnts, wHere bot <= Top -- and TheN use deFinE-ExtendEd-langUage tO aDd mORE stufF.  fOr InsTaNce, I could dEFIne A langUaGe caLled lamBdaLVar-nats that is sPEciAlized to the naTurAls lATTiCe I DEsCRibEd:
;; gRamMAR for elements of a Lattice of nAtURaL numbers.
(deFIne-ExTended-lAnguage LambdAlVar-natS
  lambdaLVAr
  (StoreVaL.... ;; EXtenD THe oRiginal lanGuage
            natUral))

;; All we
 whose value can only incr ease overtime,  wh ere  t he m eani ng of "increas e " is  given by a partiallyorder ed set( ak a a l attice) th a t  th eus erof th e lan gua ge spec ifies.  Th ere fo re lambdaLVa r  i s really a  fa mily of lang uag es --in sta n tiate  it  with  one l a tticeand you g et one la n guage;w i th  a d ifferent lattice, an d  you get anoth er.  Y ou ca n tak e a  look at t he  code here; t h ei m p ort a nt stuff is i n lambdaLVa r .rk t.
Inth e o n -paper  defi ni t ion  of lambdaL Var,  the lang uage d e finitio n  is par ameter ize d b y th a tus er- sp e cif i ed  la t tic e.  Foralo ng ti me,I ' v e  wan ted  todo th e same kind o f p aram e ter izati on in  the  R edexmodel,  butso  far, I haven't  bee n able to  fi gu reou t how .  Partofthe  troubl e is th a t t he g r am mar of the languag ed e pe nds on h ow the us er instanti at esthel a ttice : el e me nts of t he lat t ic ebecomete rminal sinthe  gram m ar. I don 't knowhow t o  express a gra m mar in Redext ha t is abst rac t over thelatt i ce.In t h emea n time,  I tr ie d  t o  make lambdaLVar.rk tas mod ularas I could. The langua g e definedin t h at file is specia lized  to a part i cular la ttice : natura l numbers w ith maxasthe  le ast - u pp er-bound (lub ) oper at ion.  ( Or,  equiva len tly , n atu ra l numbers  ordered  b y<= . It 's av ery bori ng  la tt ice .)  T h e only  part s of  t he cod e thata re s peci fi cto t hat  l attic e ar e  th e line(define l ub- o p ma x)  n ear the  top, and nat ur al appeari ng  in  the g r a mmar.  ( There's a lub metafunct i on that  is  defi nedin termsofthe us er- s pecifi ed lub -op f un cti o n .  Th e la tte ris just aR a cke t fun ct ion,  so lub  has to escape out toRacket to cal l l ub-o p . )Bar r in g  th ea bil i t y to actually s pecify lam bd a LV ar in a wa y  th at  is abs tract o ver t h e choic e of latt ice, it s ee ms l i k e I  ought tobe ableto writea  vers i on  of l amb daLVar  w ith  themost b a re- bones  of la tt ices - - jus tBot andTop elements, where Bot  <= To p --and  then use  de f ine -extended -lan guage to a ddmor e stu ff.  Forinst a nc e,I  coul d de f ine a lan g ua gec a ll ed lambdaLV a r - nat s tha t i s  speci aliz ed to the natural s  lattice I des crib e d :
; ; G r amma rfor elements o f a  l a t tice ofna tural numbe rs.
(def in e -exte nded-l anguag e lambd a L Va r -nats  la mbd aLVar
  ( Sto re V al....;;  E x tend t he o ri ginallangua g e
         natural) )

;; A ll we 
 whose_value can_only increase over time,_where the_meaning_of "increase"_is_given by a_partially ordered set_(aka a lattice) that_the user of_the_language specifies.  Therefore lambdaLVar is really a family of languages -- instantiate it_with_one lattice_and_you_get one language; with a_different lattice, and you get_another. _You can take a look at the code_here;_the important stuff_is in lambdaLVar.rkt.
In the on-paper definition of lambdaLVar, the_language definition is parameterized by that_user-specified lattice. _For_a_long time, I've wanted_to do the same kind of_parameterization in the Redex model, but_so far, I haven't been able to_figure out how. Part of the_trouble is that the grammar_of the_language depends on how the_user instantiates the_lattice: elements_of the lattice_become terminals in the grammar. _I don't know_how to express a grammar in_Redex_that is abstract_over_the_lattice.
In the_meantime, I tried_to_make lambdaLVar.rkt_as_modular as I could.  The_language_defined in that file is specialized to_a particular lattice: natural_numbers_with max as the_least-upper-bound (lub) operation.  (Or,_equivalently, natural numbers ordered by <=._ It's_a very_boring lattice.)  The only parts of the code that are_specific to that lattice are the_line (define lub-op max)_near the_top,_and natural appearing_in_the grammar._ (There's a lub metafunction that is_defined in_terms of the user-specified lub-op function._ The latter is_just_a Racket function, so lub has_to escape out to Racket to_call lub-op.)
Barring the ability to_actually_specify_lambdaLVar in a way that_is abstract over the choice of_lattice, it seems_like I ought to be able to_write_a version of lambdaLVar with the_most_bare-bones of lattices -- just Bot_and_Top_elements, where Bot <= Top_-- and then use define-extended-language to_add more stuff.  For instance, I could define_a language called_lambdaLVar-nats that is specialized to_the_naturals_lattice I described:
;; Grammar for elements of a lattice of_natural numbers.
(define-extended-language_lambdaLVar-nats
  lambdaLVar
_ (StoreVal.... ;; Extend the original language
   _      _ natural))

;; All we