type token = | VAR of string | VAL | TRUE | TIMES | THEN | SEMICOLON | RPAREN | PLUS | NUM of int | NEGATE | NAME | MINUS | DIV | LPAREN | LET | INT | IN | IF | FUN | FN | FALSE | EQUAL | NEQUAL | LT | GT | LE | GE | AND | OR | EOF | END | ELSE | DARROW | COMMA | COLON | BOOL | ARROW let token_to_str tok = match tok with | VAR x -> Format.sprintf "VAR %s" x | VAL -> "VAL" | TRUE -> "TRUE" | TIMES -> "TIMES" | THEN -> "THEN" | SEMICOLON -> "SEMICOLON" | RPAREN -> "RPAREN" | PLUS -> "PLUS" | NUM i -> Format.sprintf "NUM %d" i | NEGATE -> "NEGATE" | NAME -> "NAME" | MINUS -> "MINUS" | DIV -> "DIV" | LPAREN -> "LPAREN" | LET -> "LET" | INT -> "INT" | IN -> "IN" | IF -> "IF" | FUN -> "FUN" | FN -> "FN" | FALSE -> "FALSE" | EQUAL -> "EQUAL" | NEQUAL -> "NEQUAL" | LT -> "LT" | GT -> "GT" | LE -> "LE" | GE -> "GE" | AND -> "AND" | OR -> "OR" | EOF -> "EOF" | END -> "END" | ELSE -> "ELSE" | DARROW -> "DARROW" | COMMA -> "COMMA" | COLON -> "COLON" | BOOL -> "BOOL" | ARROW -> "ARROW" module S = struct type 'a t = Stream of (unit -> 'a front) and 'a front = | Nil | Cons of ('a * 'a t) let delay f = let memo = ref None in let memof () = match !memo with | Some g -> g | None -> let r = f () in begin memo := Some r; r end in Stream memof let force (Stream f) = f () let rec iterate f = delay (fun () -> match f () with | None -> Nil | Some x -> Cons (x, iterate f)) end module MSGS = struct let rparen_or_comma = "expect a right parenthesis or a comma" let variable = "expect a variable" end let lexer_to_stream lexer (lexbuf : Lexing.lexbuf) = S.iterate (fun () -> Some (lexer lexbuf)) let next_msg s msg = match S.force s with | S.Nil -> raise (Error msg) | S.Cons (h, t) -> (h, t) (* next s = (x,s'), where x is the head of s, s' the tail of s raises Error if stream is empty *) let next s = next_msg s "Unexpected end of stream" (* match tok s = s', s' is the tail of s raises Error if head of s does not match tok *) let tok_match tok s = let msg = Format.sprintf "Expected %s token" (token_to_str tok) in let (n, s') = next_msg s msg in if tok = n then s' else raise (Error msg) let build_primop e' (primop, e) = Primop (primop, [e'; e]) let build_primops exp op_exps = List.fold_left build_primop exp op_exps (* parse_program r = (e,s') where e is the result of parsing the beginning of r and s' the unprocessed tail of r *) let rec parse_program r = let (e, s) = parse_exp (S.delay (fun () -> S.Cons r)) Before an expression is evaluated, it is made up of a collection of "strings". These strings are data, that pass through, are analyzed, and manipulated by each sub-program. When the data passes through, it is calculated and condensed, then called to another sub-program (if required) to finish the calculation. Through displaying each sub-program as a ring on a plate, I can twist each plate 90 degrees to convey the idea of sub-program interaction through said data manipulation and calculation. The final piece was constructed by weaving string through CNC routered clear acrylic panes. Each pane was suspended by fishing wire and rotated 90˚, creating the planned concave effect. START TIME SUB-PROGRAM IS CALLED and dec = | Val of exp * name (* val x = e *) | Valtuple of exp * name list (* val (x1,...,xN) = e *) | ByName of exp * name ;; type exp = Int of int | Bool of bool | If of exp * exp * exp | Primop of primop * exp list | Tuple of exp list | Fn of (name * typ option * exp) | Rec of name * typ * exp | Let of dec list * exp | Apply of exp * exp | Var of name | Anno of exp * typ and dec = Val of exp * name | Valtuple of exp * name list | ByName of exp * name let eval_op op args = match (op, args) with | (Equals, [Int i1; Int i2]) -> Some (Bool (i1 = i2)) | (NotEquals, [Int i1; Int i2]) -> Some (Bool (i1 <> i2)) | (LessThan, [Int i1; Int i2]) -> Some (Bool (i1 < i2)) | (LessEqual, [Int i1; Int i2]) -> Some (Bool (i1 <= i2)) | (GreaterThan, [Int i1; Int i2]) -> Some (Bool (i1 > i2)) | (GreaterEqual, [Int i1; Int i2]) -> Some (Bool (i1 >= i2)) | (Plus, [Int i1; Int i2]) -> Some (Int (i1 + i2)) | (Minus, [Int i1; Int i2]) -> Some (Int (i1 - i2)) | (Times, [Int i1; Int i2]) -> Some (Int (i1 * i2)) | (Div, [Int i1; Int i2]) -> Some (Int (i1 / i2)) | (Negate, [Int i]) -> Some (Int (-i)) | _ -> None ;; val eval_op : primop -> exp list -> exp option = type context = Ctx of (name * typ) list ;; type context = Ctx of (name * typ) list exception NotFound ;; exception NotFound let ctx_lookup ctx x = let rec assoc x y = match y with | [] -> raise NotFound | (y, r) :: rest -> if x = y then r else assoc x rest in let Ctx list = ctx in assoc x list ;; val ctx_lookup : context -> name -> typ = let extend ctx (x, v) = let Ctx list = ctx in Ctx ((x,v)::list) ;; val extend : context -> name * typ -> context = let rec extend_list ctx l = match l with | [] -> ctx | (x, y) :: pairs -> extend_list (extend ctx (x, y)) pairs ;; val extend_list : context -> (name * typ) list -> context = type ('a, 'b) either = | Left of 'a | Right of 'b ;; type ('a, 'b) either = Left of 'a | Right of 'b let member = List.mem ;; val member : 'a -> 'a list -> bool = let (fresh_var, reset_ctr) = let counter = ref 0 in ((fun x -> counter := !counter+1; string_of_int (!counter) ^ x), fun () -> counter := 0) ;; val fresh_var : string -> string = val reset_ctr : unit -> unit = let debug = ref 0 ;; val debug : int ref = {contents = 0} module P : sig val parse : string -> (string, exp) either end = struct exception Error of string INTERACTION PROCESS In displaying the nature of how code interacts, found in the top right, I begin by outlining the entirety of each sub-program mapped in relation to its time complexity (x-axis) and to the time the sub-program is called (y-axis). Within this graph, I depict how/when a sub-program may be called, either through the process of another sub-program, or recursively within the sub-program itself. FINISH type name = string ;; type name = string type primop = | Equals (* v1 = v2 *) | NotEquals (* v1 != v2 *) | LessThan (* i1 < i2 *) | LessEqual (* i1 <= i2 *) | GreaterThan (* i1 > i2 *) | GreaterEqual (* i1 >= i2 *) | And (* b1 && b2 *) | Or (* b1 || b2 *) | Plus (* i1 + i2 *) | Minus (* i1 - i2 *) | Times (* i1 * i2 *) | Div (* i1 / i2 *) | Negate ;; type primop = Equals | NotEquals | LessThan | LessEqual | GreaterThan | GreaterEqual | And | Or | Plus | Minus | Times | Div | Negate exception TypeError of string ;; exception TypeError of string let type_fail message = raise (TypeError message) ;; val type_fail : string -> 'a = type typ = | TArrow of typ * typ (* a -> b *) | TProduct of typ list (* a * b *) | TInt (* int *) | TBool (* bool *) | TVar of (typ option) ref ;; type typ = TArrow of typ * typ | TProduct of typ list | TInt | TBool | TVar of typ option ref let fresh_tvar () = TVar (ref None) ;; val fresh_tvar : unit -> typ = let rec typ_eq t1 e2 = match (t1, e2) with | (TArrow (domain1, range1), TArrow (domain2, range2)) -> typ_eq domain1 domain2 && typ_eq range1 range2 | (TProduct ts1, TProduct ts2) -> List.length ts1 = List.length ts2 && List.for_all2 typ_eq ts1 ts2 | (TInt, TInt) -> true | (TBool, TBool) -> true | _ -> false ;; val typ_eq : typ -> typ -> bool = exception Stuck of string ;; exception Stuck of string let stuck message = raise (Stuck message) ;; val stuck : string -> 'a = type exp = | Int of int (* 0 | 1 | 2 | ... *) | Bool of bool (* true | false *) | If of exp * exp * exp (* if e then e1 else e2 *) | Primop of primop * exp list (* e1 e2 or e *) | Tuple of exp list (* (e1, ..., eN) *) | Fn of (name * typ option * exp) (* fn x => e *) | Rec of name * typ * exp (* rec f => e *) | Let of dec list * exp (* let decs in e end *) | Apply of exp * exp (* e1 e2 *) | Var of name (* x *) | Anno of exp * typ (* e : t *) Left: Sketch of string passing through outer diameter of rhythm graphs. Right: Process of depicting the interaction among sub-programs through data. let execute (s: string) : unit = match P.parse s with | Left s -> print_endline ("parsing failed: " ^ s) | Right e -> try (* first we type check the program *) ignore (infer (Ctx []) e); let result = eval e in print_endline ("program is evaluated to: " ^ Print.exp_to_string result) with | NotImplemented -> print_endline "code is not fully implemented" | Stuck s -> print_endline ("evaluation got stuck: " ^ s) | NotFound -> print_endline "variable lookup failed" | TypeError s -> print_endline ("type error: " ^ s) | e -> print_endline ("unknown failure: " ^ Printexc.to_string e) let rec infer (ctx : context) (e : exp) : typ = match e with | Int _ -> TInt | Bool _ -> TBool | If (e1, e2, e3) -> if (typ_eq (infer ctx e2) (infer ctx e3)) && (typ_eq (infer ctx e1) TBool) then (infer ctx e3) else type_fail "Bad arguments to If; both e2 and e3 should be of same type in an if expression and e1 should be of type bool." | Primop (p, args) -> begin match p with | Plus | Minus | Times | Div | Negate -> if List.for_all (fun x -> typ_eq (infer ctx x) (infer ctx (List.hd args))) args then TInt else type_fail "your primop requries two TInts." | And | Or | LessThan | LessEqual | GreaterThan | GreaterEqual | Equals | NotEquals -> if List.for_all (fun x -> typ_eq (infer ctx x) (infer ctx (List.hd args))) args then TBool else type_fail "you can only compare two values of the same type." end | Tuple args -> TProduct (List.map (infer ctx) args) | Fn (name, Some t, e1) -> let rec eval : exp -> exp = let ctx' = extend ctx (name, t) in let bigstep_depth = ref 0 in TArrow (t, (infer ctx' e1)) fun e -> | Fn (name, None, e1) -> if !debug >= 1 then infer ctx e1 print_endline | Rec (name, t, e1) -> (String.make (!bigstep_depth) ' ' let ctx' = extend ctx (name, t) in let rec subst ((e', x) : exp * name) (e : exp) : exp = ^ "eval (" ^ Print.exp_to_string e ^ ")\n"); infer ctx' e1 update_3 1 ; incr bigstep_depth; if not (member x (free_vars e)) then e let result = | Let (args, e1) -> else update_4 1 ; let rec extend_ctx_dec arg ctx = match e with match e with match arg with | Var y -> | Int _ | Bool _ -> e | [] -> ctx if x = y then | Tuple es -> Tuple (List.map eval es) | y::ys -> e' | If (e1, e2, e3) -> begin else begin match eval e1 with match y with Var y | Bool b -> | Val (e2, name) | ByName (e2, name) -> if b then let ctx' = extend ctx (name, (infer ctx e2)) in | Int _ | Bool _ -> e eval e2 extend_ctx_dec ys ctx' | Primop (po, es) -> Primop (po, List.map (subst (e', x)) es) else | Valtuple ((Tuple e3), namelist) -> let rec unused_vars (e : exp) : name list = | If (e1, e2, e3) -> If (subst (e', x) e1, subst (e', x) e2, subst (e', x) e3) let rec ctx_namelist_helper e_h namelist_h ctx_acc = eval e3 match e with | Tuple es -> Tuple (List.map (subst (e', x)) es) | _ -> stuck "Condition for if expression should be of the type bool" begin | If (e1, e2, e3) -> | Anno (e, t) -> Anno ((subst (e', x) e), t) end match (e_h, namelist_h) with union (unused_vars e1) (union (unused_vars e2) (unused_vars e3)) | Anno (e, _) -> eval e (* types are ignored in evaluation *) | (_, []) | ([], _) -> ctx_acc | Primop (p, exp_list) -> | Let (ds, e2) -> | Var x -> stuck ("Free variable \"" ^ x ^ "\" during evaluation") | ((x::xs), (n::ns)) -> List.fold_right (fun e1 -> union (unused_vars e1)) exp_list [] begin let ctx' = extend ctx_acc (n, (infer ctx_acc x)) in | Tuple exp_list -> let rec check ds_o e_h ds_a = | Fn (x, t, e) -> Fn (x, t, e) ctx_namelist_helper xs ns ctx' List.fold_right (fun e1 -> union (unused_vars e1)) exp_list [] begin | Apply (e1, e2) -> end | Fn (name, t, e1) -> match ds_o with begin in extend_ctx_dec ys (ctx_namelist_helper e3 namelist ctx) if member name (free_vars e1) then | [] -> Let ((ds_a), (subst (e', x) e_h)) e1) with | _ -> type_fail "Bad arguments to let; valtuple mustmatch take (eval in a tuple and namelist" (delete [name] (unused_vars e1)) else (union [name] (unused_vars e1)) | y::ys -> match y with | Fn (x, t, e) -> eval (subst ((eval e2), x) e) end | Rec (name, t, e1) -> | Val (e3, name) | ByName (e3, name) -> | _ -> stuck "Condition for Apply expression should be of the type Fn" in if member name (free_vars e1) then if name = x then end infer (extend_ctx_dec args ctx) e1 (delete [name] (unused_vars e1)) else (union [name] (unused_vars e1)) Let ((ds_a), e2) | Rec (f, t, e) -> eval (subst ((Rec (f, t, e)), f) e) | Let (args, e1) -> else check ys e_h ds_a | Apply (e1, e2) -> begin | Valtuple (e4, namelist) -> | Primop (And, es) -> begin match args with if member x namelist then begin let inf_e1 = infer ctx e1 in | [] -> unused_vars e1 Let ((ds_a), e2) match es with match inf_e1 with | y::ys -> else check ys e_h ds_a | [Bool x; Bool y] -> Bool (x&&y) | (TArrow (t1, t2)) -> t2 begin end in -> stuck "Condition for Primop AND should be of the type Bool" | _ -> type_fail "Applys first argument must be a function |of_ type: TArrow (t1, t2)" match y with let rec helper_fun ds_origional ds_helper e_helper ds_acc = end end | Val (e2, name) | ByName (e2, name) -> begin | Primop (Or, es) -> if member name (free_vars e2) || member name (free_vars e1) then match ds_helper with begin | Var n1 -> ctx_lookup ctx n1 delete [name] (union (union (unused_vars (Let (ys,e1))) | [] -> check ds_origional e_helper ds_acc match es with | Anno (e1, typ) -> (unused_vars e2)) (unused_vars e1)) | h::ts -> | [Bool x; Bool y] -> Bool (x||y) if typ_eq (infer ctx e1) typ then typ else match h with _ -> stuck "Condition for Primop OR should be of the type Bool" else type_fail "Anno's expression and type should be of same |type." union (union [name] (unused_vars e2)) (union (unused_vars (Let | Val (e3, name) -> end (ys,e1))) (unused_vars e1)) if member name (free_vars e') then | Primop (op, es) -> | Valtuple (e3, name_l) -> let fn = fresh_var name in let vs = List.map eval es in List.fold_right (fun name free_variable -> helper_fun ds_origional ts (subst ((Var fn), name) e_helper) begin match eval_op op vs with if member name (free_vars e1) || member name (free_vars e3) (ds_acc @ [Val ((subst (e', x) e3), fn)]) | None -> stuck "Bad arguments to primitive operation" then else | Some v -> v union (delete [name] (union (union (unused_vars e3) helper_fun ds_origional ts e_helper end (unused_vars (Let (ys,e1)))) (unused_vars e1))) free_variable (ds_acc @ [Val ((subst (e', x) e3), name)]) else | ByName (e4, name) -> | Let (ds, e) -> union (union (union [name] (unused_vars e3)) (union if member name (free_vars e') then let rec helper ds1 e_acc = (unused_vars (Let (ys, e1))) (unused_vars e1))) free_variable let fn = fresh_var name in begin ) name_l [] helper_fun ds_origional ts (subst ((Var fn), name) e_helper) match ds1 with end (ds_acc @ [ByName ((subst (e', x) e4), fn)]) | [] -> eval e_acc end else | y::ys -> | Apply (e1, e2) -> union (unused_vars e1) (unused_vars e2) helper_fun ds_origional ts e_helper begin | Var e1 -> if member e1 (free_vars (Var e1)) (ds_acc @ [ByName ((subst (e', x) e4), name)]) match y with then [] | Valtuple (e5, namelist) -> | Val (e3, name) | ByName (e3, name) -> else [e1] let rec namelist_check nl_h e_h nl_a = helper ys (subst ((eval e3), name) e_acc) | Anno (e1, typ) -> unused_vars e1 begin | Valtuple ((Tuple e4), namelist) -> | Int _ | Bool _ -> [] match nl_h with let rec namelist_helper e_h namelist_h eh_acc = | [] -> helper_fun ds_origional ts e_h (ds_acc @ [Valtuple ((subst (e', x) e5), nl_a)]) begin | y::ys -> match (e_h, namelist_h) with if member y (free_vars e') then | (_, []) | ([], _) -> eh_acc let fn = fresh_var y in | ((x::xs), (n::ns)) -> namelist_check ys (subst ((Var fn), y) e_h) (nl_a @ [fn]) namelist_helper xs ns (subst ((eval x), n) eh_acc) else namelist_check ys (e_h) (nl_a @ [y]) end end in namelist_check namelist e_helper [] in helper ys (namelist_helper (e4) namelist e) end in helper_fun ds ds e2 [] | _ -> stuck "Bad arguments to let; valtuple must take in a tuple and namelist" end end | Apply (e1, e2) -> end Apply ((subst (e', x) e1), (subst (e', x) e2)) in helper ds e | Fn (y, t, e) -> in if y = x then decr bigstep_depth; Fn (y, t, e) else if !debug >= 1 then if member y (free_vars e') then print_endline let fv = fresh_var y in (String.make (!bigstep_depth) ' ' Fn ((fv), t, (subst (e', x) (subst (Var fv, y) e))) ^ "result of eval (" ^ Print.exp_to_string e ^ ") = " else Fn (y, t, (subst (e', x) e)) ^ Print.exp_to_string result ^ "\n"); | Rec (y, t, e) -> result if y = x then Rec (y, t, e) else if member y (free_vars e') then let fv = fresh_var y in Rec ((fv), t, (subst (e', x) (subst (Var fv, y) e))) else Rec (y, t, (subst (e', x) e)) TIME COMPLEXITY: DIAMETER OF RHYTHM GRAPH