Finally tagless, partially evaluated - Cornell University...Finally tagless, partially evaluated...

Finally tagless, partially evaluatedTagless staged interpreters for simpler typed languages

Jacques Carette Oleg Kiselyov Chung-chieh Shan

December 2, 2011

tanakawho on flickr

The goal of this talk

Write your interpreter by deforesting the object language,to exhibit more static safety in a simpler type system.

There’s interpretation everywhereA fold on an inductive data type is an interpreter of adomain-specific language.

contract grammar music �-term . . .

schedule

pretty-print

typeset

performevaluate

compile

. . . . . . . . . . . .

evaluate

compilespecialize

CPS transform

pretty-print

schedule

pretty-print

typeset

performevaluate

compile

. . . . . . . . . . . .

evaluate

compilespecialize

CPS transform

pretty-print

The same language can be interpreted in many useful ways.

schedule

pretty-print

typeset

performevaluate

compile

. . . . . . . . . . . .

evaluate

compilespecialize

CPS transform

pretty-print

We focus on the �-calculus as an example.

Simple type preservation

Typed source language

Typed metalanguage

BOOL true:

Typed target languages

It should be obvious in the metalanguage that interpreting awell-typed source term yields a well-typed target term.

3 � 4

evaluate

BOOL true:

LEQ (LIT 3, LIT 4): term

evaluate

eval: term -> value

eval (LIT i) = INT i

eval (LEQ (e1,e2)) =

match (eval e1, eval e2) with

(INT i, INT j) -> BOOL (i <= j)

BOOL true: value

eval: term -> value

BOOL true: value

eval: term -> value

BOOL true: value

The term should be well-typed, so pattern matching in themetalanguage should always obviously succeed.

eval: term -> value

BOOL true: value

The term should be closed, so environment lookup in themetalanguage should always obviously succeed.

LEQ (LIT 3, LIT 4): bool term

eval: ’a term -> ’a value

BOOL true: bool value

Previous solutions use (and motivate) fancier types:generalized abstract data types (GADT) and dependent types.

leq (lit 3, lit 4): bool

lit: int -> int

lit i = i

leq: int * int -> bool

leq (i,j) = i <= j

true: bool

Our simple solution is to be finally tagless:replace term constructors by cogen functions.

Simply typed �-calculus

Haskell constructor instancesor ML modules

BOOL true:

evaluatecompile

specialize

CPS transform

The term accommodates multiple interpretationsby abstracting over the cogen functions and their types.

Outline

I The object languageAs a constructor class in HaskellAs a module signature in ML

Tagless interpretationEvaluationCompilation

Type-indexed typesPartial evaluationCPS transformation

The object language

[x : t1]��

e : t2�x: e : t1 ! t2

[f : t1 ! t2]��

e : t1 ! t2

�x f: e : t1 ! t2

e1 : t1 ! t2 e2 : t1e1e2 : t2

n is an integern : int

b is a booleanb : bool

e1 : int e2 : int

e1 + e2 : int

e1 : int e2 : int

e1 � e2 : int

e1 : int e2 : int

e1 � e2 : bool

e : bool e1 : t e2 : t

if e then e1 else e2 : t

�x: �x f: �n:if n � 0 then 1 elsex� f(n� 1)

: int! int! int

The object language

[x : t1]��

e : t2�x: e : t1 ! t2

[f : t1 ! t2]��

e : t1 ! t2

�x f: e : t1 ! t2

e1 : t1 ! t2 e2 : t1e1e2 : t2

n is an integern : int

b is a booleanb : bool

e1 : int e2 : int

e1 + e2 : int

e1 : int e2 : int

e1 � e2 : int

e1 : int e2 : int

e1 � e2 : bool

e : bool e1 : t e2 : t

if e then e1 else e2 : t

: int! int! int

The object language as a constructor classclass Symantics repr where

int :: Int -> repr Int

lam :: (repr a -> repr b) -> repr (a -> b)

fix :: (repr a -> repr a) -> repr a

app :: repr (a -> b) -> repr a -> repr b

add :: repr Int -> repr Int -> repr Int

if_ :: repr Bool -> repr a -> repr a -> repr a

: int! int! int

Object term Haskell term

�x: �x f: �n: lam (\x -> fix (\f -> lam (\n ->

if n � 0 then 1 else if_ (leq n (int 0)) (int 1)

x� f(n� 1) (mul x (app f (add n (int (-1))))))))

: int! int! int :: Symantics repr => repr (Int -> Int -> Int)

The object language as a module signaturemodule type Symantics = sig type (’c,’a) repr

val int: int -> (’c,int) repr

val lam: ((’c,’a) repr -> (’c,’b) repr) -> (’c,’a->’b) repr

val fix: (’x -> ’x) -> ((’c,’a->’b) repr as ’x)

val app: (’c,’a -> ’b) repr -> (’c,’a) repr -> (’c,’b) repr

val add: (’c,int) repr -> (’c,int) repr -> (’c,int) repr

val if_: (’c,bool) repr -> (unit -> ’x) -> (unit -> ’x)

-> ((’c,’a) repr as ’x)

: int! int! int

-> ((’c,’a) repr as ’x)

: int! int! int

-> ((’c,’a) repr as ’x)

Object term ML functor

�x: �x f: �n: lam (fun x -> fix (fun f -> lam (fun n ->

if n � 0 then 1 else if_ (leq n (int 0)) (fun () -> int 1)

x� f(n� 1) (fun () -> mul x (app f (add n (int (-1))))))))

: int! int! int (’c, int -> int -> int) repr

-> ((’c,’a) repr as ’x)

ML functor

�x: �x f: �n:

lam (fun x -> fix (fun f -> lam (fun n ->

if n � 0 then 1 else

if_ (leq n (int 0)) (fun () -> int 1)

x� f(n� 1)

(fun () -> mul x (app f (add n (int (-1))))))))

: int! int! int

(’c, int -> int -> int) repr

-> ((’c,’a) repr as ’x)

ML functormodule POWER (S:Symantics) = struct open S

let term () =

�x: �x f: �n:

lam (fun x -> fix (fun f -> lam (fun n ->

if n � 0 then 1 else

if_ (leq n (int 0)) (fun () -> int 1)

x� f(n� 1)

(fun () -> mul x (app f (add n (int (-1))))))))

end: functor (S:Symantics) -> sig

val term: unit ->

: int! int! int

(’c, int -> int -> int) S.repr

Composing object programs as functors

��x: �x f: �n: if n � 0 then 1 else x� f(n� 1)

module POWER7 (S:Symantics) = struct open S

module P = POWER(S)

let term () = lam (fun x -> app (app (P.term ()) x)

(int 7))

val term: unit -> (’c, int -> int) S.repr

�x:��x: �x f: �n: if n � 0 then 1 else x� f(n� 1)

�x 7

module P = POWER(S)

(int 7))

�x:��x: �x f: �n: if n � 0 then 1 else x� f(n� 1)

�x 7

module P = POWER(S)

(int 7))

Outline

The object languageAs a constructor class in HaskellAs a module signature in ML

I Tagless interpretationEvaluationCompilation

Type-indexed typesPartial evaluationCPS transformation

Tagless interpretation: EvaluationNo worry about pattern matching or environment lookup!Well-typed source programs obviously don’t go wrong.

module R = struct

type (’c,’a) repr = ’a

let int (x:int) = x

let lam f = fun x -> f x

let fix g = let rec f n = g f n in f

let app e1 e2 = e1 e2

let add e1 e2 = e1 + e2

let if_ e e1 e2 = if e then e1 () else e2 ()

⟨fun x -> (fun x -> let rec self = fun x ->

(fun x -> if x <= 0 then 1 else x * self (x + (-1)))

x in self) x 7⟩

module R = struct

let int (x:int) = x

module POWER7R = POWER7(R)

I POWER7R.term () 2

x in self) x 7⟩

module R = struct

let int (x:int) = x

x in self) x 7⟩

module R = struct

type (’c,’a) repr =

(’c,

) code

let int (x:int) =

let lam f =

fun x ->

⟩)⟩

let fix g =

let rec f n =

n in f

let app e1 e2 =

let add e1 e2 =

let if_ e e1 e2 =

e then

x in self) x 7⟩

Tagless interpretation: CompilationNo worry about pattern matching or environment lookup!Well-typed source programs obviously translate to well-typedtarget programs.

module C = struct

type (’c,’a) repr = (’c,’a) code

let int (x:int) = ⟨x⟩let lam f = ⟨fun x -> ~(f ⟨x⟩)⟩let fix g = ⟨let rec f n = ~(g ⟨f⟩) n in f⟩let app e1 e2 = ⟨~e1 ~e2⟩let add e1 e2 = ⟨~e1 + ~e2⟩let if_ e e1 e2 = ⟨if ~e then ~(e1 ()) else ~(e2 ())⟩

x in self) x 7⟩

Tagless interpretation: CompilationNo worry about pattern matching or environment lookup!Well-typed source programs obviously translate to well-typedtarget programs.

module C = struct

type (’c,’a) repr = (’c,’a) code

let int (x:int) = ⟨x⟩let lam f = ⟨fun x -> ~(f ⟨x⟩)⟩let fix g = ⟨let rec f n = ~(g ⟨f⟩) n in f⟩let app e1 e2 = ⟨~e1 ~e2⟩let add e1 e2 = ⟨~e1 + ~e2⟩let if_ e e1 e2 = ⟨if ~e then ~(e1 ()) else ~(e2 ())⟩

module POWER7C = POWER7(C)

I POWER7C.term ()

x in self) x 7⟩

Outline

The object languageAs a constructor class in HaskellAs a module signature in ML

Tagless interpretationEvaluationCompilation

I Type-indexed typesPartial evaluationCPS transformation

Partial evaluationmodule P = struct

module type Symantics = sig type (’c,’s,’a) repr

val int: int -> (’c,int,int) repr

val lam: ’x -> (’c, (’c,’s,’a) repr ->

(’c,’t,’b) repr as ’x, ’a -> ’b) repr

val fix: ((’c, (’c,’s,’a) repr -> (’c,’t,’b) repr,

’a -> ’b) repr as ’x -> ’x) -> ’x

val app: (’c, (’c,’s,’a) repr ->

(’c,’t,’b) repr as ’x, ’a -> ’b) repr -> ’x

val add: ’x -> ’x -> ((’c,int,int) repr as ’x)

val if_: (’c,bool,bool) repr -> (unit->’x) -> (unit->’x)

-> ((’c,’s,’a) repr as ’x)

type (’c, ’a) repr

source term 3 x

dynamic part ⟨3⟩ ⟨x⟩* int option static part Some 3 None

endtype (’c,int->int) repr �x: 1� x f

= (’c,int->int) code ⟨fun x->x⟩ ⟨f⟩module POWER7P = POWER7(P)* ((’c,int) repr -> Some (fun r->r) None

I POWER7P.term ()(’c,int) repr) option

(⟨fun x -> x * x * x * x * x * x * x⟩, Some <fun>)

type (’c,’a) repr

= (’c,’a) code

* (’c,’a) static option

type (’c, int) static = int

type (’c, bool) static = bool

type (’c, ’a -> ’b) static = (’c,’a) repr -> (’c,’b) repr

interpret

Partial evaluation

module P = structmodule type Symantics = sig type (’c,’s,’a) repr

’a -> ’b) repr as ’x -> ’x) -> ’x

-> ((’c,’s,’a) repr as ’x)

type (’c,int) repr

source term 3 x

= (’c,int) code

dynamic part ⟨3⟩ ⟨x⟩

* int option

static part Some 3 None

= (’c,’a) code

interpret

Partial evaluation

’a -> ’b) repr as ’x -> ’x) -> ’x

-> ((’c,’s,’a) repr as ’x)

type (’c,int) repr source term

= (’c,int) code dynamic part

⟨3⟩ ⟨x⟩

* int option static part

Some 3 None

= (’c,’a) code

interpret

Partial evaluation

’a -> ’b) repr as ’x -> ’x) -> ’x

-> ((’c,’s,’a) repr as ’x)

type (’c,int) repr source term 3

= (’c,int) code dynamic part ⟨3⟩

⟨x⟩

* int option static part Some 3

= (’c,’a) code

interpret

Partial evaluation

’a -> ’b) repr as ’x -> ’x) -> ’x

-> ((’c,’s,’a) repr as ’x)

type (’c,int) repr source term 3 x

= (’c,int) code dynamic part ⟨3⟩ ⟨x⟩* int option static part Some 3 None

= (’c,’a) code

interpret

Partial evaluation

’a -> ’b) repr as ’x -> ’x) -> ’x

-> ((’c,’s,’a) repr as ’x)

type (’c,int->int) repr

�x: 1� x f

= (’c,int->int) code

⟨fun x->x⟩ ⟨f⟩module POWER7P = POWER7(P)

* ((’c,int) repr ->

Some (fun r->r) None

I POWER7P.term ()

(’c,int) repr) option

= (’c,’a) code

interpret

Partial evaluation

’a -> ’b) repr as ’x -> ’x) -> ’x

-> ((’c,’s,’a) repr as ’x)

type (’c,int->int) repr

�x: 1� x

= (’c,int->int) code

⟨fun x->x⟩

⟨f⟩

module POWER7P = POWER7(P)

* ((’c,int) repr ->

Some (fun r->r)

I POWER7P.term ()

= (’c,’a) code

interpret

Partial evaluation

’a -> ’b) repr as ’x -> ’x) -> ’x

-> ((’c,’s,’a) repr as ’x)

type (’c,int->int) repr �x: 1� x f

= (’c,int->int) code ⟨fun x->x⟩ ⟨f⟩

* ((’c,int) repr -> Some (fun r->r) None

I POWER7P.term ()

= (’c,’a) code

interpret

Partial evaluation

’a -> ’b) repr as ’x -> ’x) -> ’x

-> ((’c,’s,’a) repr as ’x)

I POWER7P.term ()

= (’c,’a) code

* ??? option

interpret

Partial evaluation

’a -> ’b) repr as ’x -> ’x) -> ’x

-> ((’c,’s,’a) repr as ’x)

I POWER7P.term ()

= (’c,’a) code

interpret

Type-indexed types

’a -> ’b) repr as ’x -> ’x) -> ’x

-> ((’c,’s,’a) repr as ’x)

= (’c,’a) code

interpret

Type-indexed types

module P = struct

’a -> ’b) repr as ’x -> ’x) -> ’x

-> ((’c,’s,’a) repr as ’x)

= (’c,’a) code

interpret

Type-indexed types: Partial evaluationmodule P = struct

’a -> ’b) repr as ’x -> ’x) -> ’x

-> ((’c,’s,’a) repr as ’x)

source term 3 x

= (’c,’a) code

interpret

’a -> ’b) repr as ’x -> ’x) -> ’x

-> ((’c,’s,’a) repr as ’x)

type (’c,’s,’a) repr

source term 3 x

= (’c,’a) code

* ’s option

= (’c,’a) code

interpret

’a -> ’b) repr as ’x -> ’x) -> ’x

-> ((’c,’s,’a) repr as ’x)

source term 3 x

= (’c,’a) code

* ’s option

I POWER7P.term ()

= (’c,’a) code

interpret

Type-indexed types: CPS transformation

’a -> ’b) repr as ’x -> ’x) -> ’x

-> ((’c,’s,’a) repr as ’x)

source term 3 x

= (’s -> ans) -> ans (* CBN CPS evaluator *)

= (’c, (’s -> ans) -> ans) code (* CBN CPS compiler *)

= (’c,’a) code

interpret

CPS transformations

Simply typed �-calculus

CBV CBN

evaluate

compile specialize

Payoffs: evaluation order independence, mutable state

Other benefits

Supports initial type-checkingType-check once, even under �, then interpret many times.

FilePath -> Maybe (exists a. Typeable a =>

forall repr. Symantics repr =>

repr a)

“Typing dynamic typing” (ICFP 2002) works. We have the code.

Preserves sharing in the metalanguageCompute the interpretation of a repeated object term once,then use it many times.2� 3 + 2� 3 let n = mul (int 2) (int 3) in add n n

Embed one object language in another(Symantics repr, Symantics’ repr’) => repr (repr’ Int)

Other benefits

repr a)

Other benefits

repr a)

Conclusion

Write your interpreter by deforesting the object languageI An abstract data type familyI Type-indexed types

Exhibit more static safety in a simpler type systemI Early, obvious guaranteesI Supports initial type-checkingI Preserves sharing in the metalanguageI Embed one object language in another

Finally tagless, partially evaluated - Cornell University...Finally tagless, partially evaluated...

Documents

Evaluated Scientifically

Combinators for Impure yet Hygienic Code Generationokmij.org/ftp/tagless-final/TaglessStaged/beyond.pdfCombinators for Impure yet Hygienic Code Generation Yukiyoshi Kameyama Tsukuba,

Actor-Critic Policy Optimization in Partially Observable ...papers.nips.cc/paper/7602-actor-critic-policy-optimization-in-partially-observable... · Partially observable environments

INVENTORY MANAGEMENT WITH PARTIALLY … MANAGEMENT WITH PARTIALLY OBSERVED NONSTATIONARY DEMAND ... a discrete-time Markov chain have been ... INVENTORY MANAGEMENT WITH PARTIALLY OBSERVED

Finally Tagless, Partially Evaluated - okmij.orgokmij.org/ftp/tagless-final/JFP.pdf · Finally Tagless, Partially Evaluated 3 If our OCaml-like metalanguage were untyped, the code

* Partially sponsored by IARPA SPAR * Partially sponsored by DARPA PROCEED

Partially Subsidised Device Schedule - Hearing …hearingservices.gov.au/hsoViewWEB/file/partially...Partially Subsidised Device Schedule Manufacturer Device Code Device Type Model

Partially Revised Draft Environmental Impact Report San ...sjrc.ca.gov/wp-content/uploads/2014/06/Partially-Revised...Partially Revised Draft Environmental Impact Report San Joaquin

t-shirts - White Paper Office Solutions · Pocketed t-shirts * 99/1 cotton/poly ** 90/10 cotton/poly. 84 NEW! Hanes Tagless® Youth T - 10.2-oz, 100% ComfortSoft® cotton - Tagless

Flash-Point Prediction for Binary Partially Miscible ... · Flash-Point Prediction for Binary Partially Miscible Aqueous-Organic Mixtures ... Prediction for Binary Partially Miscible

2016 External Quality Review - medicaid.ms.gov€¦ · 2016 External Quality Review Magnolia Health Plan | March 22, 2017 2016 Met Partially Met Not Met Not Evaluated Not Applicable

Partially commutative inverse monoidsinf.informatik.uni-stuttgart.de/fmi/ti/personen/Lohrey/... · 2007. 1. 9. · partially commutative monoids (trace monoids), free partially commutative

cdn.ymaws.comSecure Site cdn.ymaws.com/ · Partially Restrained Composite Connection: Partially restrained connections as defined in Ref. 7-1 between partially or fully composite

A Tagless Coherence Directorymoshovos/research/tagless...taining cache coherence in an efficient manner. Directory-based protocols avoid the bandwidth overhead of snoop-based protocols,

Have you evaluated?

Properties of Partially Stabilized Zirconia … OF PARTIALLY STABILIZED ZIRCONIA COMPONENTS ... a sintering study ... Properties of Partially Stabilized Zirconia Components Fabricated

Partially Ordered Set

Evaluated Configuration Guide

A Fully Associative, Tagless DRAM Cacheicc.skku.ac.kr/~jaewlee/pubs/isca15_tagless.pdf · A Fully Associative, Tagless DRAM Cache Yongjun Lee† Jongwon Kim† Hakbeom Jang† Hyunggyun

Information-Theoretic Methods for Planning and Learning in Partially Observable Markov … · 2020. 11. 1. · 1.1 Partially Observable Markov Decision Processes A Partially Observable