For-Comprehension

encore.cabal

@@ -80,6 +80,7 @@ executable encorec
                , Makefile
                , ModuleExpander
                , Optimizer.Optimizer
+               , Optimizer.TypedDesugarer
                , Parser.Parser
                , SystemUtils
                , Typechecker.Capturechecker

modules/standard/Boxed/MutBox.enc

@@ -0,0 +1,10 @@
+module MutBox
+
+local class MutBox[t]
+
+  var value : t
+
+  def init( v : t) : unit
+    this.value = v
+  end
+end

modules/standard/Collections/Mutable/ArrayList.enc

@@ -4,8 +4,9 @@ import Data.Maybe(cat_maybes)
 import Data.Either
 import Data.Array
 import Collections.Mutable.Collection
+import Collections.Mutable.Functor
 
-local class ArrayList[t] : Collection[t](next_empty, int_arr, foreach(), shift_right(), shift_left(), ensure_can_accomodate(), resize())
+local class ArrayList[t] : Collection[t](next_empty, int_arr, foreach(), shift_right(), shift_left(), ensure_can_accomodate(), resize()) + Functor[t](map(), flatMap())
   var int_arr    : [Maybe[t]]
   var next_empty : uint
 
@@ -151,7 +152,7 @@ local class ArrayList[t] : Collection[t](next_empty, int_arr, foreach(), shift_r
     val clone = new ArrayList[t]()
 
     for x <- this.int_arr do
-      match x with 
+      match x with
         case Just(ice) => clone.append(ice)
         case Nothing => { break; () }
       end

modules/standard/Collections/Mutable/Functor.enc

@@ -0,0 +1,8 @@
+module Functor
+import Collections.Mutable.Collection
+
+local trait Functor[t]
+  require def map[u](f : local ((t) -> u)) : Functor[u]
+  require def flatMap[u](f : local ((t) -> Functor[u])) : Collection[u]
+  require def foreach(f : local ((t) -> unit)) : unit
+end

modules/standard/Collections/Mutable/HashMap.enc

@@ -44,11 +44,11 @@ local class HashMapIterator[k : Hashable + Eq[k], v]
     this.current_index = this.current_index + 1
 
     while this.current_index < this.map.size do
-      val l = (this.map.internal_map)(this.current_index) 
+      val l = (this.map.internal_map)(this.current_index)
       if l.size > 0 then
         return l.first
       end
-     
+
       this.current_index = this.current_index + 1
     end
 
@@ -107,7 +107,7 @@ local class HashMap[k : Hashable + Eq[k], v] : Map[k, v](size, internal_map, ite
   def init() : unit
     this.items = 0
     this.size = 32
-    this.internal_map = Array.new_with_generator(this.size, 
+    this.internal_map = Array.new_with_generator(this.size,
                                                  fun (x: int) => new LinkedList[Entry[k,v]]())
   end
 
@@ -277,7 +277,7 @@ local class HashMap[k : Hashable + Eq[k], v] : Map[k, v](size, internal_map, ite
     end
     result
   end
-  
+
   def populate(pairs : [(k, v)]) : unit
     for kv <- pairs do
       this.set(kv.0, kv.1)

modules/standard/Collections/Mutable/LinkedList.enc

@@ -3,7 +3,8 @@ module LinkedList
 import Data.Either
 import Data.Maybe
 import Collections.Mutable.Collection
--- import Collections.Mutable.Iterable
+
+import Collections.Mutable.Functor
 
 local class LinkedNode[t] : Id
   var value : t
@@ -16,7 +17,7 @@ local class LinkedNode[t] : Id
   end
 end
 
-local class LinkedList[t] : Collection[t](drop(), first, last, size) + Id
+local class LinkedList[t] : Collection[t](drop(), first, last, size) + Id + Functor[t](first, map(), flatMap(), foreach())
   var first : Maybe[LinkedNode[t]]
   var last  : Maybe[LinkedNode[t]]
   var size  : int
@@ -325,7 +326,7 @@ local class LinkedList[t] : Collection[t](drop(), first, last, size) + Id
     end
   end
 
-  def map[u](f : t -> u) : LinkedList[u]
+  def map[u](f : local ((t) -> u)) : LinkedList[u]
     val result = new LinkedList[u]()
 
     -- Iterate over list, perform f() on each value, put result in new list.
@@ -358,7 +359,8 @@ local class LinkedList[t] : Collection[t](drop(), first, last, size) + Id
     return result
   end
 
-  def flatMap[u](f : t -> LinkedList[u]) : LinkedList[u]
+
+  def flatMap[u](f : local ((t) -> Functor[u])) : LinkedList[u]
     val result = new LinkedList[u]()
 
     var cursor = this.first

modules/standard/Data/Array.enc

@@ -4,7 +4,7 @@ module Array
 
 -- new_with_default :: (int, a) -> [a]
 -- new_with_default(size, default) creates an array of size default
--- with each element 
+-- with each element
 fun new_with_default[a](size : int, default : a) : [a]
   val arr = new [a](size)
   for i <- [0 .. size - 1] do
@@ -72,8 +72,8 @@ end
 -- count(pred, arr) counts the number of elements of arr satisfying predicate pred
 fun count[a](pred : a -> bool, arr : [a]) : int
   var count = 0
-  for a <- arr do
-    if pred(a) then
+  for x <- arr do
+    if pred(x) then
       count += 1
     end
   end
@@ -83,14 +83,76 @@ end
 -- map :: (a -> b, [a]) -> [b]
 -- map(f, arr) produces a new array containing the results of applying f to the
 -- elements of arr
-fun map[a,b](f : a -> b, arr : [a]) : [b]
+fun map[a,b](f : local ((a) -> b), arr : [a]) : [b]
   val ret = new [b](|arr|)
-  for i <- [0 .. |arr|-1] do
+  var i = 0
+  while (i <= |arr|-1) do
     ret(i) = f((arr)(i))
+    i += 1
   end
   ret
 end
 
+-- flatMap :: (a -> [b], [a]) -> [b]
+-- flatMap(f, arr) produces a new array containeing the flatened results of applying f to
+-- the elements of arr
+fun flatMap[a, b](f : local ((a) -> [b]), arr : [a]) : [b]
+  val size = |arr|
+  var result = new [b](0)
+  var i = 0
+  while (i < size) do
+    var ret = f(arr(i))
+    result = concat[b](result, ret)
+    i += 1
+  end
+  return result
+end
+
+-- foreach(a -> unit, [a]) -> unit
+-- forach(f, arr) applied f to all elements of an array, resulting in unit.
+fun foreach[a](f : local ((a) -> unit), arr : [a]) : unit
+  val size = |arr|
+  var i = 0
+  while i < size do
+    f(arr(i))
+    i += 1
+  end
+end
+
+
+fun maybeForeach[a](f : local ((a) -> Maybe[unit]), arr : [a]) : Maybe[unit]
+  val size = |arr|
+  var i = 0
+  while i < size do
+    var res = f(arr(i))
+    if res == Nothing then
+      return Nothing
+    end
+    i += 1
+  end
+  return Just(())
+end
+
+-- concat :: ([a], [a]) -> [a]
+-- concat(firstArr, secondArr) produces a new array that is the concatination of
+-- the two input arrays.
+fun concat[a](firstArr : [a], secondArr : [a]) : [a]
+  val firstSize = |firstArr|
+  val secondSize = |secondArr|
+  val result = new [a](firstSize + secondSize)
+  var i = 0
+  while i < firstSize do
+    result(i) = firstArr(i)
+    i += 1
+  end
+  var j = 0
+  while j < secondSize do
+    result(j+firstSize) = secondArr(j)
+    j += 1
+  end
+  return result
+end
+
 -- show :: (a -> unit, [a]) -> unit
 -- show(showEl, arr) prints out array arr using function showEl to print the elements
 -- of the array
@@ -123,7 +185,7 @@ fun contains[t](arr : [t], to_find : t) : bool
 end
 
 -- contains_str :: ([String], String) -> bool
--- contains_str(arr, elem) is true if and only if elem appears in arr 
+-- contains_str(arr, elem) is true if and only if elem appears in arr
 -- tested using String.compare
 fun contains_str(arr : [String], to_find : String) : bool
   var retval = false
@@ -147,7 +209,7 @@ fun clone[t](src : [t]) : [t]
 end
 
 -- nclone :: ([t], int) -> Maybe[[t]]
--- nclone(arr,n) results in Just(arr') where arr' is a new array containing 
+-- nclone(arr,n) results in Just(arr') where arr' is a new array containing
 -- the first n elements of arr, in the case where n < |arr|, otherwise Nothing
 -- a new array containing the same contents as arr
 fun nclone[t](src : [t], n : uint) : Maybe[[t]]
@@ -160,5 +222,4 @@ fun nclone[t](src : [t], n : uint) : Maybe[[t]]
     end
     Just(new_arr)
   end
-end
-
+end

modules/standard/Data/Maybe.enc

@@ -2,11 +2,11 @@ module Maybe
 
 import qualified Data.Array as A
 
--- This package implements common functions for operating on 
+-- This package implements common functions for operating on
 -- Maybe types. It is inspired heavily by Data.Maybe in Haskell.
 
--- unjust :: Maybe[a] -> a 
--- unjust(mval) eliminates the Just constructor, assuming that the 
+-- unjust :: Maybe[a] -> a
+-- unjust(mval) eliminates the Just constructor, assuming that the
 -- mval is Just(x). Results in an error otherwise
 fun unjust[a](mval : Maybe[a]) : a
   match mval with
@@ -18,8 +18,8 @@ fun unjust[a](mval : Maybe[a]) : a
   end
 end
 
--- unjust_with_default :: (a, Maybe[a]) -> a 
--- unjust_with_default(default, mval) eliminates the Just constructor from mval, 
+-- unjust_with_default :: (a, Maybe[a]) -> a
+-- unjust_with_default(default, mval) eliminates the Just constructor from mval,
 -- assuming that the input value is Just(x). Results in an default, otherwise
 fun unjust_with_default[a](default : a, mval : Maybe[a]) : a
   maybe(default, id[a], mval)
@@ -54,7 +54,7 @@ fun is_just[a](mval : Maybe[a]) : bool
     case Nothing => false
   end
 end
-  
+
 -- is_nothing :: Maybe[a] -> bool
 -- is_nothing(mval) is true whenever mval is Nothing
 fun is_nothing[a](mval : Maybe[a]) : bool
@@ -91,19 +91,18 @@ end
 fun cat_maybes[a](marr : [Maybe[a]]) : [a]
   val arr = new [a](A.count(is_just[a], marr))  -- why do I need [a]?
   var count = 0
-  for a <- marr do
-    if is_just(a) then
-      arr(count) = unjust(a)
+  for b <- marr do
+    if is_just(b) then
+      arr(count) = unjust(b)
       count += 1
     end
   end
   arr
 end
 
 -- map_maybe :: (a -> Maybe[a], [a]) -> [b]
--- map_maybe(f, arr) maps the function f on the array producing a new array, 
+-- map_maybe(f, arr) maps the function f on the array producing a new array,
 -- filtering out elements that result in Nothing
 fun map_maybe[a,b](f : a -> Maybe[b], arr : [a]) : [b]
   cat_maybes[b](A.map[a, Maybe[b]](f, arr))
 end
-

modules/standard/Data/RRange.enc

@@ -0,0 +1,33 @@
+module RRange
+
+read class RRange
+  val start : int
+  val stop : int
+  val step : int
+
+  def init(start : int, stop : int, step : int) : unit
+    this.start = start
+    this.stop = stop
+    this.step = step
+  end
+
+  def foreach(f : local ((int) -> unit)) : unit
+    var current = this.start
+    while (current <= this.stop) do
+      f(current)
+      current += this.step
+    end
+  end
+
+  def maybeForeach(f : local ((int) -> Maybe[unit])) : Maybe[unit]
+    var current = this.start
+    while (current <= this.stop) do
+      var ret = f(current)
+      if ret == Nothing then
+        return Nothing
+      end
+      current += this.step
+    end
+    return Just(())
+  end
+end

src/back/CCode/Main.hs

@@ -30,6 +30,7 @@ class UsableAs a b where
 instance UsableAs Name Lval where
 instance UsableAs Lval Expr where
 instance UsableAs Name Expr where
+
 instance UsableAs a a where
 
 instance UsableAs Stat Expr where

src/back/CodeGen/Closure.hs

@@ -25,7 +25,6 @@ import Types as Ty
 
 import Control.Monad.State hiding (void)
 import Control.Arrow(first)
-import Debug.Trace
 
 varSubFromTypeVars :: [Type] -> [(ID.Name, CCode Lval)]
 varSubFromTypeVars = map each