For-Comprehension

critik

@@ -0,0 +1,9 @@
+The first slide after introduction: Have a picture?
+
+One of the first slidess: Align "::"
+
+gotward delegation: picture with printers again? 19
+
+26: Make the chosen example bigger on like the next slide? Hard to see. Especially when using cursive:make bigger or bold or something
+27: --------""---------
+28: Make the examples bigger. 

encore.cabal

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

forComp/output.enc

@@ -0,0 +1,15 @@
+typeCheckSource sourceType fors@(ForSource{fsTy, collection}) = do
+    collectionTyped <- doTypecheck collection
+    let collectionType = AST.getType collectionTyped
+    formalType <- findFormalRefType collectionType
+    let mtyType = return $ getInnerType collectionType
+    unless (formalType == sourceType) $
+      pushError collection $ TypeMismatchError formalType sourceType
+    return fors{fsTy = mtyType
+               ,collection = setType collectionType collectionTyped}
+
+firstSourceType ForSource{fsTy, collection} = do
+    collectionTyped <- doTypecheck collection
+    let collectionType = AST.getType collectionTyped
+    formal <- findFormalRefType collectionType
+    return formal

forComp/rangeFor.enc

@@ -0,0 +1,10 @@
+active class Main
+  def main() : unit
+    var range = new Range(1, 10, 2)
+    range.foreach(print_index)
+  end
+end
+
+fun print_index(i: int) : unit
+  print("{ }", i)
+end

forComp/tests/preliminaryFailSyntaxTests.enc

@@ -0,0 +1,45 @@
+--These are preliminary for-comprehension tests
+-- The following assumptions have been made:
+--  1. It is possible to loop over empty structures
+--     which either does nothing,
+--     or returns a new struct that is empty.
+--  2. It is possible to loop over different kinds of structures
+--     If using for as a function call, it will return
+--     a similar struct as the first one listed, but perhaps
+--     containing elements of different type.
+--  3. Looping over multiple structures is done in a nested may:
+--        for x <- [1, 2], y <- [3, 4]
+--     would loop over all the y elements for every x element
+--  4. Mutable variables can be changed inside a for-loop
+--  5. To use for over a structure, it must only allow one type of element
+--     i.e. be homogenous, thus for example, it cannot iterate over a tuple
+--  6. The following tests assume there is a simple Container LinkedList which
+--     has support for map and flatMap.
+
+--None of these examples should compile at all
+
+active class Main
+
+  def main() : unit
+
+    -- indentation error
+    for x <- [1, 2, 3] do
+    end
+
+    -- "<- list" missing
+    for x do
+      x + 1
+    end
+
+    -- "<-" missing
+    for x = [1, 2, 3] do
+      x + 1
+    end
+
+    -- [] is not allowed in Encore
+    for x <- [] do
+      x + 1
+    end
+
+  end
+end

forComp/tryEquals.enc

@@ -0,0 +1,36 @@
+active class Equal
+
+  var num : int
+
+  def init() : unit
+    this.num = 3
+  end
+
+  def isEqual(num : int) : bool
+    return (this.num == num)
+  end
+
+end
+
+active class Main
+
+  def main(args : [String]) : unit
+
+    var n = match (args(1)).to_int() with
+              case Just(res) =>
+                res
+              end
+              case Nothing =>
+                0
+              end
+            end
+    var instance = new Equal()
+    var b = instance!isEqual(n)
+    print("They are equal? {}\n", get(b))
+
+    if ([1, 2, 3].isEqual([1, 2, 3])) then
+      print("It does not work!")
+    end
+
+  end
+end

forComp/tryFor.enc

@@ -0,0 +1,55 @@
+import Collections.Mutable.LinkedList
+
+fun accum(mun : int) : int
+  mun + 1
+end
+
+fun useList(list : LinkedList[(int, String)]) : unit
+  for elem <- list do
+    print("{}", elem)
+  end
+end
+
+active class Main
+  def main() : unit
+
+    var list  = new LinkedList[int]()
+    list.append(1)
+    list.append(2)
+    list.append(3)
+
+    var list2  = new LinkedList[String]()
+    list2.append("katt")
+    list2.append("katt")
+    list2.append("katt")
+
+    var acc = 0
+    useList(for elem <- list, el <- list2 do
+                    (elem, el)
+            end)
+
+
+    {-var list  = new LinkedList[int]()
+    list.append(1)
+    list.append(2)
+    list.append(3)
+
+    var list2  = new LinkedList[int]
+    list2.append(5)
+    list2.append(6)
+
+    var list3 = for x <- list, y <- list2 do
+                  x + y
+                end
+
+    for x <- list do
+      print("{}\n", x)
+    end
+
+    for e <- list3 do
+      print("{}", e)
+    end-}
+
+
+  end
+end

forComp/tryInt.enc

@@ -0,0 +1,24 @@
+active class TryInt
+
+  var num : Integer
+
+  def init() : unit
+    this.num = 3
+  end
+
+  def add(num : Integer) : unit
+    this.num.add(num)
+    print("New value: {}", this.num)
+  end
+
+end
+
+active class Main
+
+  def main(args : [String]) : unit
+
+    var n = 3 : Integer
+    var instance = new TryInt()
+    instance!add(n)
+  end
+end

forComp/tryLinkedList.enc

@@ -0,0 +1,7 @@
+import Collections.Mutable.LinkedList
+
+active class Main
+  def main() : unit
+    var list = new LinkedList()
+  end
+end

modules/standard/Collections/Mutable/ArrayList.enc

@@ -4,8 +4,10 @@ import Data.Maybe(cat_maybes)
 import Data.Either
 import Data.Array
 import Collections.Mutable.Collection
+-- JOY for-comprehension
+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 +153,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
@@ -304,7 +306,7 @@ local class ArrayList[t] : Collection[t](next_empty, int_arr, foreach(), shift_r
 
     return result
   end
-  
+
   def underlying() : [t]
     cat_maybes(this.int_arr)
   end

modules/standard/Collections/Mutable/Functor.enc

@@ -0,0 +1,7 @@
+module Functor
+
+local trait Functor[t]
+  require def map[u](f : t -> u) : Functor[u]
+  require def flatMap[u](f : t -> Functor[u]) : Functor[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

@@ -4,6 +4,8 @@ import Data.Either
 import Data.Maybe
 import Collections.Mutable.Collection
 -- import Collections.Mutable.Iterable
+-- JOY for-comprehension
+import Collections.Mutable.Functor
 
 local class LinkedNode[t] : Id
   var value : t
@@ -16,7 +18,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
@@ -358,7 +360,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 : t -> Functor[u]) : LinkedList[u]
     val result = new LinkedList[u]()
 
     var cursor = this.first