Source lean/Determinize/Frontend/Pretty.lean
import Determinize.Frontend.Syntaxnamespace Determinize.Frontendopen Spec.Paperdef prettyAffinity : Affinity → String | .E => "E" | .G => "G"def prettyType : Ty → String  | .unit => "unit"  | .bool => "bool"  | .float m => s!"float[{prettyAffinity m}]"  | .prod a b => s!"({prettyType a} * {prettyType b})"  | .sum a b => s!"({prettyType a} + {prettyType b})"  | .list a => s!"[{prettyType a}]"  | .arr a b => s!"({prettyType a} -> {prettyType b})"private partial def decimalPlaces (denominator : Nat) : Option Nat :=  if denominator == 1 then some 0  else    let factor := denominator.gcd 10    if factor ≤ 1 then none else (· + 1) <$> decimalPlaces (denominator / factor)private def literal (q : Rat) : String :=  if q.den == 1 then toString q.num  else match decimalPlaces q.den with  | none => s!"({q.num} / {q.den})"  | some places =>    let scale := 10 ^ places    let numerator := q.num.natAbs * (scale / q.den)    let fraction := toString (numerator % scale)    let padding := String.ofList (List.replicate (places - fraction.length) '0')    s!"{if q.num < 0 then "-" else ""}{numerator / scale}.{padding}{fraction}"def leanAction : DistributionAction → String  | .sample affinity => s!"(.sample .{prettyAffinity affinity})"  | .mean => ".mean"/-- How `pretty` writes the site of a primitive: `head name site` is the head of theapplication, such as `uniform[E]`. -/class PrettySite (Site : Type) where  head (name : String) : Site → Stringinstance : PrettySite DistributionAction where  head name := fun    | .sample affinity => s!"{name}[{prettyAffinity affinity}]"    | .mean => "mean_" ++ nameinstance : PrettySite Affinity where  head name affinity := s!"{name}[{prettyAffinity affinity}]"/-- A placeholder prints as an omitted affinity. -/instance : PrettySite (Option Affinity) where  head name := fun    | some affinity => s!"{name}[{prettyAffinity affinity}]"    | none => nameprivate def primitive {Site : Type} [PrettySite Site] (name : String) (site : Site)    (args : List String) : String :=  s!"{PrettySite.head name site}({String.intercalate ", " args})"private def render {Site : Type} [PrettySite Site] (env : List String) (depth : Nat) :    Expr Rat Site → String  | .bvar i => (env[i]?).getD s!"unbound_{i}"  | .reject => "observe(false)"  | .unit => "()"  | .bool b => toString b  | .real q => literal q  | .lam b => let x := s!"x{depth}"; s!"(fun {x} => {render (x :: env) (depth + 1) b})"  | .fix b => let f := s!"f{depth}"; let x := s!"x{depth}";      s!"(rec {f} {x} => {render (x :: f :: env) (depth + 1) b})"  | .app a b => s!"({render env depth a} {render env depth b})"  | .pair a b => s!"({render env depth a}, {render env depth b})"  | .fst a => s!"(fst {render env depth a})"  | .snd a => s!"(snd {render env depth a})"  | .inl a => s!"(inl {render env depth a})"  | .inr a => s!"(inr {render env depth a})"  | .matchSum e a b => let x := s!"x{depth}";      s!"(match {render env depth e} with inl {x} => {render (x :: env) (depth + 1) a} \          | inr {x} => {render (x :: env) (depth + 1) b})"  | .nil => "[]"  | .cons h t => s!"({render env depth h} :: {render env depth t})"  | .matchList e n c => let x := s!"x{depth}"; let xs := s!"xs{depth}";      s!"(match {render env depth e} with [] => {render env depth n} | {x} :: {xs} => \          {render (x :: xs :: env) (depth + 1) c})"  | .ite c .unit .reject => s!"observe({render env depth c})"  | .ite c a b => s!"(if {render env depth c} then {render env depth a} else {render env depth b})"  | .letE a b => let x := s!"x{depth}";      s!"(let {x} = {render env depth a} in {render (x :: env) (depth + 1) b})"  | .neg a => s!"(-{render env depth a})"  | .add a b => s!"({render env depth a} + {render env depth b})"  | .mul a b => s!"({render env depth a} * {render env depth b})"  | .div a b => s!"({render env depth a} / {render env depth b})"  | .lt a b => s!"({render env depth a} < {render env depth b})"  | .uniform k a b => primitive "uniform" k [render env depth a, render env depth b]  | .gaussian k a b => primitive "gauss" k [render env depth a, render env depth b]  | .poisson k a => primitive "poisson" k [render env depth a]  | .discrete k p => primitive "discrete_list" k [render env depth p]  | .bernoulli k a => primitive "bernoulli" k [render env depth a]  | .exponential k a => primitive "exponential" k [render env depth a]  | .beta k a b => primitive "beta" k [render env depth a, render env depth b]  | .gamma k a b => primitive "gamma" k [render env depth a, render env depth b]/-- Surface syntax, which the parser reads back as the same program unless the program has a meansite: the parser knows no `mean_<dist>` names. -/def pretty {Site : Type} [PrettySite Site] (e : Expr Rat Site) : String := render [] 0 e/-- Constructor syntax for independent kernel checking; every rational is parenthesized. -/def leanExpression : Core → String  | .bvar index => s!"(.bvar {index})"  | .reject => "(.reject)"  | .unit  => s!"(.unit)"  | .bool value => s!"(.bool {value})"  | .real value => s!"(.real (({value.num} : Rat) / {value.den}))"  | .lam body => s!"(.lam {leanExpression body})"  | .fix body => s!"(.fix {leanExpression body})"  | .app fn arg => s!"(.app {leanExpression fn} {leanExpression arg})"  | .pair left right => s!"(.pair {leanExpression left} {leanExpression right})"  | .fst pairValue => s!"(.fst {leanExpression pairValue})"  | .snd pairValue => s!"(.snd {leanExpression pairValue})"  | .inl value => s!"(.inl {leanExpression value})"  | .inr value => s!"(.inr {leanExpression value})"  | .matchSum scrutinee left right =>    s!"(.matchSum {leanExpression scrutinee} {leanExpression left} {leanExpression right})"  | .nil  => s!"(.nil)"  | .cons head tail => s!"(.cons {leanExpression head} {leanExpression tail})"  | .matchList scrutinee nilCase consCase =>    s!"(.matchList {leanExpression scrutinee} {leanExpression nilCase} {leanExpression consCase})"  | .ite condition thenBranch elseBranch =>    s!"(.ite {leanExpression condition} {leanExpression thenBranch} {leanExpression elseBranch})"  | .letE value body => s!"(.letE {leanExpression value} {leanExpression body})"  | .neg body => s!"(.neg {leanExpression body})"  | .add left right => s!"(.add {leanExpression left} {leanExpression right})"  | .mul left right => s!"(.mul {leanExpression left} {leanExpression right})"  | .div left right => s!"(.div {leanExpression left} {leanExpression right})"  | .lt left right => s!"(.lt {leanExpression left} {leanExpression right})"  | .uniform action lower upper =>    s!"(.uniform {leanAction action} {leanExpression lower} {leanExpression upper})"  | .gaussian action mean variance =>    s!"(.gaussian {leanAction action} {leanExpression mean} {leanExpression variance})"  | .poisson action rate => s!"(.poisson {leanAction action} {leanExpression rate})"  | .discrete action p => s!"(.discrete {leanAction action} {leanExpression p})"  | .bernoulli action probability =>    s!"(.bernoulli {leanAction action} {leanExpression probability})"  | .exponential action rate => s!"(.exponential {leanAction action} {leanExpression rate})"  | .beta action alpha betaArg =>    s!"(.beta {leanAction action} {leanExpression alpha} {leanExpression betaArg})"  | .gamma action shape rate =>    s!"(.gamma {leanAction action} {leanExpression shape} {leanExpression rate})"end Determinize.Frontend