API tools faq
paste
Advertisement
VladNitu

InterpFunctionsResit20-21Nistor

VladNitu
May 25th, 2023
107
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 13.72 KB | None | 0 0
raw download clone embed print report
  1. import Library._
  2.  
  3. object Interp {
  4.  
  5. def interp(e: ExprC, nv: List[Bind]): Value = e match {
  6. case NumC(n) => NumV(n)
  7. case PlusC(l, r) => (interp(l, nv), interp(r, nv)) match {
  8. case (NumV(n1), NumV(n2)) => NumV(n1 + n2)
  9. case p => throw InterpException("Bad addition. Expected two numbers, but got: " + p)
  10. }
  11. case MultC(l, r) => (interp(l, nv), interp(r, nv)) match {
  12. case (NumV(n1), NumV(n2)) => NumV(n1 * n2)
  13. case p => throw InterpException("Bad multiplication. Expected two numbers, but got: " + p)
  14. }
  15. case MinusC(l, r) => (interp(l, nv), interp(r, nv)) match {
  16. case (NumV(n1), NumV(n2)) => NumV(n1 - n2)
  17. case p => throw InterpException("Bad subtraction. Expected two numbers, but got: " + p)
  18. }
  19. case TrueC() => BoolV(true)
  20. case FalseC() => BoolV(false)
  21. case EqNumC(l, r) => (interp(l, nv), interp(r, nv)) match {
  22. case (NumV(n1), NumV(n2)) => BoolV(n1 == n2)
  23. case p => throw InterpException("Bad number equality. Expected two numbers, but got: " + p)
  24. }
  25. case IfC(c, t, e) => interp(c, nv) match {
  26. case BoolV(b) => b match {
  27. case true => interp(t, nv)
  28. case false => interp(e, nv)
  29. }
  30. case _ => throw InterpException("If err")
  31. }
  32. case AppC(f, arg) => interp(f, nv) match {
  33. case ClosV(param, body, nv_clos) =>
  34. val argInterp = interp(arg, nv)
  35. interp(body, Bind(param, argInterp) :: nv_clos)
  36.  
  37. case _ => throw InterpException("AppC err")
  38. }
  39. case IdC(x) => nv.find(bd => bd.x == x) match {
  40. case Some(Bind(_, vl)) => vl
  41. case _ => {
  42. println(nv)
  43. throw InterpException("x not found in nv")
  44. }
  45. }
  46. case FunctionsC(funs, cont) =>
  47. val closures = funs.map(fun => ClosV(fun.param, fun.body, Nil))
  48. val funs_clos = funs.zip(closures).map(fun_clos => Bind(fun_clos._1.f, fun_clos._2))
  49. var largeNv = nv
  50. funs_clos.foreach(fun_clos => largeNv = fun_clos :: largeNv)
  51.  
  52. closures.foreach(clos => clos.nv = largeNv)
  53. interp(cont, funs_clos ::: nv)
  54.  
  55.  
  56. }
  57. }
  58.  
  59. // import Library._
  60. //
  61. // object Interp {
  62. //
  63. // // def interpFun(fun: FunC, nv: List[Bind]): ClosV = {
  64. //
  65. //
  66. //
  67. // // }
  68. //
  69. // def interp(e: ExprC, nv: List[Bind]): Value = e match {
  70. // case NumC(n) => NumV(n)
  71. // case PlusC(l, r) => (interp(l, nv), interp(r, nv)) match {
  72. // case (NumV(n1), NumV(n2)) => NumV(n1 + n2)
  73. // case p => throw InterpException("Bad addition. Expected two numbers, but got: " + p)
  74. // }
  75. // case MultC(l, r) => (interp(l, nv), interp(r, nv)) match {
  76. // case (NumV(n1), NumV(n2)) => NumV(n1 * n2)
  77. // case p => throw InterpException("Bad multiplication. Expected two numbers, but got: " + p)
  78. // }
  79. // case MinusC(l, r) => (interp(l, nv), interp(r, nv)) match {
  80. // case (NumV(n1), NumV(n2)) => NumV(n1 - n2)
  81. // case p => throw InterpException("Bad subtraction. Expected two numbers, but got: " + p)
  82. // }
  83. // case TrueC() => BoolV(true)
  84. // case FalseC() => BoolV(false)
  85. // case EqNumC(l, r) => (interp(l, nv), interp(r, nv)) match {
  86. // case (NumV(n1), NumV(n2)) => BoolV(n1 == n2)
  87. // case p => throw InterpException("Bad number equality. Expected two numbers, but got: " + p)
  88. // }
  89. // case IfC(c, t, e) => interp(c, nv) match {
  90. // case BoolV(true) => interp(t, nv)
  91. // case BoolV(false) => interp(e, nv)
  92. // case _ => throw InterpException(s"$c does not evaluate to Boolean")
  93. // }
  94. // case AppC(f, arg) => interp(f, nv) match {
  95. // case ClosV(param, body, nv_clos) =>
  96. // val interpArg = interp(arg, nv)
  97. // interp(body, Bind(param, interpArg) :: nv_clos)
  98. //
  99. // case _ => throw throw InterpException(s"$f does not eval. to ClosV")
  100. // }
  101. //
  102. // case IdC(x) => nv.find(bnd => bnd.x == x) match {
  103. // case Some(Bind(_, v)) => v
  104. // case _ => throw throw InterpException(s"$x not present in $nv")
  105. // }
  106. // case FunctionsC(funs, cont) =>
  107. //
  108. // var newNv = nv
  109. // val closures = funs.map(fun => ClosV(fun.param, fun.body, Nil))
  110. //
  111. // val funs_clos = funs.map(_.f).zip(closures).map(fun_clos => Bind(fun_clos._1, fun_clos._2)) // (fName, Clos)
  112. //
  113. // funs_clos.foreach(fun_clos => newNv = fun_clos :: newNv)
  114. //
  115. // closures.foreach(clos => clos.nv = newNv)
  116. //
  117. // interp(cont, newNv)
  118. //
  119. //
  120. //
  121. // // var newNv = nv
  122. // // val closures = funs.map(fun => ClosV(fun.param, fun.body, Nil))
  123. // // val functionBinds = funs.map(_.f).zip(closures).map(fun_clos => Bind(fun_clos._1, fun_clos._2))
  124. //
  125. // // // println(functionBinds)
  126. // // // functionBinds.foreach(x => print(x.v))
  127. // // // functionBinds.foreach(x => print(x.v match {
  128. // // // case ClosV(_, _, nv) => nv
  129. // // // }))
  130. //
  131. // // closures.foreach(clos => clos.nv = functionBinds ::: nv)
  132. //
  133. // // interp(cont, functionBinds ::: nv)
  134. //
  135. // }
  136. // }
  137. //
  138. // // import Library._
  139. // //
  140. // // object Interp {
  141. // //
  142. // //
  143. // // def bindFun(fun: FuncC, curNv: List[Bind]): ClosV = {
  144. // // val newNv = Bind(fun.f, ClosV(fun.param, fun.body, curNv)) :: curNv
  145. // // ClosV(fun.f, fun.body, newNv)
  146. // // }
  147. // //
  148. // // def interp(e: ExprC, nv: List[Bind]): Value = e match {
  149. // // case NumC(n) => NumV(n)
  150. // // case PlusC(l, r) => (interp(l, nv), interp(r, nv)) match {
  151. // // case (NumV(n1), NumV(n2)) => NumV(n1 + n2)
  152. // // case p => throw InterpException("Bad addition. Expected two numbers, but got: " + p)
  153. // // }
  154. // //
  155. // // case MultC(l, r) => (interp(l, nv), interp(r, nv)) match {
  156. // // case (NumV(n1), NumV(n2)) => NumV(n1 * n2)
  157. // // case p => throw InterpException("Bad multiplication. Expected two numbers, but got: " + p)
  158. // // }
  159. // // case MinusC(l, r) => (interp(l, nv), interp(r, nv)) match {
  160. // // case (NumV(n1), NumV(n2)) => NumV(n1 - n2)
  161. // // case p => throw InterpException("Bad subtraction. Expected two numbers, but got: " + p)
  162. // // }
  163. // // case TrueC() => BoolV(true)
  164. // // case FalseC() => BoolV(false)
  165. // // case EqNumC(l, r) => (interp(l, nv), interp(r, nv)) match {
  166. // // case (NumV(n1), NumV(n2)) => BoolV(n1 == n2)
  167. // // case p => throw InterpException("Bad number equality. Expected two numbers, but got: " + p)
  168. // // }
  169. // // case IfC(c, t, e) => interp(c, nv) match {
  170. // // case BoolV(true) => interp(t, nv)
  171. // // case BoolV(false) => interp(e, nv)
  172. // // case _ => throw InterpException(s"IF: $c not a Boolean")
  173. // // }
  174. // // case AppC(f, arg) => interp(f, nv) match {
  175. // // case ClosV(x, body, nv_clos) => {
  176. // // val argInterp = interp(arg, nv)
  177. // // val newNv = Bind(x, argInterp) :: nv_clos
  178. // //
  179. // // interp(body, newNv ::: nv)
  180. // //
  181. // // }
  182. // // case _ =>throw InterpException(s"AppC: $f does evaluate to a function")
  183. // // }
  184. // // case IdC(x) => nv.find(bind => bind. x == x) match {
  185. // // case Some(Bind(_, v)) => v
  186. // // case None => throw InterpException(s"$x not found in nv")
  187. // // }
  188. // // case FunctionsC(funs, cont) =>
  189. // // var curNv = nv
  190. // // funs.map(fun => {
  191. // // val bindsFun: ClosV = bindFun(fun, curNv)
  192. // // curNv = bindsFun.nv
  193. // //
  194. // // })
  195. // //
  196. // // interp(cont, curNv)
  197. // // }
  198. // // }
  199. // //
  200. // // // import Library._
  201. // // //
  202. // // // object Interp {
  203. // // //
  204. // // // def lookup(x: String, nv: List[Bind]): Value = nv match {
  205. // // // case bind :: t => if (bind.x == x) bind.v else lookup(x, t)
  206. // // // case _ => throw InterpException(s"$x not found in nv_lookup")
  207. // // // }
  208. // // //
  209. // // // def bindFunction(fun: FuncC, nv: List[Bind]): ClosV = {
  210. // // //
  211. // // // val bind = Bind(fun.f, ClosV(fun.param, fun.body, nv))
  212. // // // var newEnv = bind :: nv
  213. // // // ClosV(fun.f, fun.body, newEnv)
  214. // // // }
  215. // // //
  216. // // // def interp(e: ExprC, nv: List[Bind]): Value = e match {
  217. // // // case NumC(n) => NumV(n)
  218. // // // case PlusC(l, r) => (interp(l, nv), interp(r, nv)) match {
  219. // // // case (NumV(n1), NumV(n2)) => NumV(n1 + n2)
  220. // // // case p => throw InterpException("Bad addition. Expected two numbers, but got: " + p)
  221. // // // }
  222. // // // case MultC(l, r) => (interp(l, nv), interp(r, nv)) match {
  223. // // // case (NumV(n1), NumV(n2)) => NumV(n1 * n2)
  224. // // // case p => throw InterpException("Bad multiplication. Expected two numbers, but got: " + p)
  225. // // // }
  226. // // // case MinusC(l, r) => (interp(l, nv), interp(r, nv)) match {
  227. // // // case (NumV(n1), NumV(n2)) => NumV(n1 - n2)
  228. // // // case p => throw InterpException("Bad subtraction. Expected two numbers, but got: " + p)
  229. // // // }
  230. // // // case TrueC() => BoolV(true)
  231. // // // case FalseC() => BoolV(false)
  232. // // // case EqNumC(l, r) => (interp(l, nv), interp(r, nv)) match {
  233. // // // case (NumV(n1), NumV(n2)) => BoolV(n1 == n2)
  234. // // // case p => throw InterpException("Bad number equality. Expected two numbers, but got: " + p)
  235. // // // }
  236. // // // case IfC(c, t, e) => interp(c, nv) match {
  237. // // // case BoolV(b) => if (b) interp(t, nv) else interp(e, nv)
  238. // // // case _ => throw InterpException(s"$c not Bool")
  239. // // // }
  240. // //
  241. // // //
  242. // // // case AppC(f, arg) => interp(f, nv) match {
  243. // // // case ClosV(x, e, nv_clos) =>
  244. // // //
  245. // // // val interpArg = interp(arg, nv)
  246. // // // val binds = Bind(x, interpArg) :: nv_clos
  247. // // // interp(e, binds ::: nv)
  248. // // // // val params_nv = Bind(x, interp(e, nv_clos)) :: nv_clos
  249. // // // // val interpArg = interp(arg, nv)
  250. // // // // interp(e, )
  251. // // // case _ => throw InterpException(s"$f is not a ClosV")
  252. // // //
  253. // // // }
  254. // // // case IdC(x) => lookup(x, nv)
  255. // // // case FunctionsC(funs, cont) =>
  256. // // // var nvGl: List[Bind] = nv
  257. // // // funs.map(fun => {
  258. // // // val closv: ClosV = bindFunction(fun, nvGl)
  259. // // // nvGl = closv.nv
  260. // // // }
  261. // // // )
  262. // // //
  263. // // // interp(cont, nvGl)
  264. // // // }
  265. // // // }
  266. // // //
  267. // // // // import Library._
  268. // // // //
  269. // // // // object Interp {
  270. // // // //
  271. // // // // def lookup(x: String, nv: List[Bind]): Value = nv match {
  272. // // // // case Bind(name, value) :: t => if (name == x) value else lookup(x, t)
  273. // // // // case Nil => throw InterpException(s"$x was not found in env. $nv")
  274. // // // // }
  275. // // // //
  276. // // // // def bindFunction(fun: FuncC, nv: List[Bind]): ClosV = {
  277. // // // // val closBind = Bind(fun.f, ClosV(fun.param, fun.body, nv))
  278. // // // // var newEnv = closBind :: nv
  279. // // // //
  280. // // // // newEnv(0).v match {
  281. // // // // case ClosV(_, _, nvOld) => ClosV(_, _, newEnv)
  282. // // // // case _ => throw new InterpException("")
  283. // // // // }
  284. // // // //
  285. // // // // ClosV(fun.f, fun.body, newEnv)
  286. // // // // }
  287. // // // //
  288. // // // //
  289. // // // // def interp(e: ExprC, nv: List[Bind]): Value = e match {
  290. // // // // case NumC(n) => NumV(n)
  291. // // // // case PlusC(l, r) => (interp(l, nv), interp(r, nv)) match {
  292. // // // // case (NumV(n1), NumV(n2)) => NumV(n1 + n2)
  293. // // // // case p => throw InterpException("Bad addition. Expected two numbers, but got: " + p)
  294. // // // // }
  295. // // // // case MultC(l, r) => (interp(l, nv), interp(r, nv)) match {
  296. // // // // case (NumV(n1), NumV(n2)) => NumV(n1 * n2)
  297. // // // // case p => throw InterpException("Bad multiplication. Expected two numbers, but got: " + p)
  298. // // // // }
  299. // // // // case MinusC(l, r) => (interp(l, nv), interp(r, nv)) match {
  300. // // // // case (NumV(n1), NumV(n2)) => NumV(n1 - n2)
  301. // // // // case p => throw InterpException("Bad subtraction. Expected two numbers, but got: " + p)
  302. // // // // }
  303. // // // // case TrueC() => BoolV(true)
  304. // // // // case FalseC() => BoolV(false)
  305. // // // // case EqNumC(l, r) => (interp(l, nv), interp(r, nv)) match {
  306. // // // // case (NumV(n1), NumV(n2)) => BoolV(n1 == n2)
  307. // // // // case p => throw InterpException("Bad number equality. Expected two numbers, but got: " + p)
  308. // // // // }
  309. // // // // case IfC(c, t, e) => interp(c, nv) match {
  310. // // // // case BoolV(b) => if (b) interp(t, nv) else interp(e, nv)
  311. // // // // case _ => throw new InterpException("Should not reach this")
  312. // // // // }
  313. // // // // case AppC(f, arg) => interp(f, nv) match {
  314. // // // // case ClosV(x, body, nv_clos) =>
  315. // // // // val argInterp = interp(arg, nv)
  316. // // // // val newNv = Bind(x, argInterp) :: nv_clos ::: nv
  317. // // // // interp(body, newNv)
  318. // // // //
  319. // // // //
  320. // // // // case _ => throw new InterpException(s"$f is not a Closure")
  321. // // // // }
  322. // // // // case IdC(x) => lookup(x, nv)
  323. // // // //
  324. // // // // case FunctionsC(funs, cont) => {
  325. // // // // var lastNv = nv;
  326. // // // // val ans = funs.map(fun => {
  327. // // // // val closv: ClosV = bindFunction(fun, lastNv)
  328. // // // // lastNv = closv.nv
  329. // // // // })
  330. // // // //
  331. // // // // interp(cont, lastNv)
  332. // // // // }
  333. // // // //
  334. // // // // }
  335. // // // // }
  336. // // // //
  337.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!