Started adding enum implementation

bryanjos · bryanjos · commit 2c90deadad02 · 2017-03-20T22:15:35.000-05:00
diff --git a/lib/elixir_script/translator.ex b/lib/elixir_script/translator.ex
@@ -83,6 +83,10 @@ defmodule ElixirScript.Translator do
     JSLib.translate_js_function({:__aliases__, context, rest}, function_name, params, env)
   end
 
+  defp do_translate({:__aliases__, context, [:JS | rest]}, env) do
+    JSLib.translate_js_module({:__aliases__, context, rest}, env)
+  end
+
   defp do_translate(ast, env) when is_number(ast) or is_binary(ast) or is_boolean(ast) or is_nil(ast) do
     { Primitive.make_literal(ast), env }
   end
diff --git a/lib/elixir_script/translator/kernel/js.ex b/lib/elixir_script/translator/kernel/js.ex
@@ -42,6 +42,14 @@ defmodule ElixirScript.Translator.JS do
     { do_translate({name, [], params}, env), env }
   end
 
+  def translate_js_module(module, env) do
+    { do_translate(module, env), env }
+  end
+
+  defp do_translate({:__aliases__, _, module}, env) do
+    Identifier.make_namespace_members(module)
+  end
+
   defp do_translate({op, _, [param]}, env) when op in [:typeof, :delete, :void, :-, :+, :!, :"~"] do
     Builder.unary_expression(
       op,
diff --git a/lib/elixir_script/translator/state.ex b/lib/elixir_script/translator/state.ex
@@ -23,6 +23,8 @@ defmodule ElixirScript.Translator.State do
     |> Map.put(Collectable, ElixirScript.Collectable)
     |> Map.put(String.Chars, ElixirScript.String.Chars)
     |> Map.put(Enumerable, ElixirScript.Enumerable)
+    |> Map.put(Enum, ElixirScript.Enum)
+    |> Map.put(Enum.OutOfBoundsError, ElixirScript.Enum.OutOfBoundsError)
     |> Map.put(Integer, ElixirScript.Integer)
     |> Map.put(Macro.Env, ElixirScript.Macro.Env)
     |> Map.put(View, ElixirScript.View)
diff --git a/priv/std_lib/base.ex b/priv/std_lib/base.ex
@@ -2,7 +2,7 @@ defmodule ElixirScript.Base do
   @moduledoc false
 
   def encode64(data) do
-    ElixirScript.Bootstrap.b64EncodeUnicode(data)
+    ElixirScript.Bootstrap.Functions.b64EncodeUnicode(data)
   end
 
   defp can_decode64(data) do
diff --git a/priv/std_lib/bootstrap/functions.ex b/priv/std_lib/bootstrap/functions.ex
@@ -36,10 +36,10 @@ defmodule ElixirScript.Bootstrap.Functions do
   end
 
   def b64EncodeUnicode(str) do
-    {:ok, regex} = Regex.compile("%([0-9A-F]{2})", "g")
+    regex = Regex.compile!("%([0-9A-F]{2})", "g")
 
     JS.btoa(
-      JS.encodeURIComponent(str).replace(regex, fn (match, p1) ->
+      JS.encodeURIComponent(str).replace(regex, fn (match, p1, _, _) ->
         JS.String.fromCharCode("0x#{p1}")
       end)
     )
diff --git a/priv/std_lib/enum.ex b/priv/std_lib/enum.ex
@@ -0,0 +1,289 @@
+defmodule ElixirScript.Enum do
+  
+  def all?(enumerable, fun \\ fn(x) -> x end) do
+    {_, acc} = Enumerable.reduce(enumerable, {:cont, true}, fn(item, _) ->
+      if fun.(item) do
+        {:cont, true}
+      else
+        {:halt, false}
+      end
+    end)
+
+    acc
+  end
+
+  def any?(enumerable, fun \\ fn(x) -> x end) do
+    {_, acc} = Enumerable.reduce(enumerable, {:cont, true}, fn(item, _) ->
+      if fun.(item) do
+        {:halt, true}
+      else
+        {:cont, false}
+      end
+    end)
+
+    acc
+  end
+
+  def at(enumerable, n, default \\ nil) do
+    cond do
+      n > Enumerable.count(enumerable) ->
+        default
+      true ->
+        result = Enumerable.reduce(enumerable, {:cont, 0}, fn(item, acc) ->
+          if n == acc do
+            {:halt, item}
+          else
+            {:cont, acc + 1}
+          end
+        end)
+
+        case result do
+          {:cont, _} ->
+            default
+          {:halt, item} ->
+            item
+        end
+    end
+  end
+
+  def concat([enumerable]) do
+    enumerable
+  end
+
+  def concat([h | t]) do
+    h.concat(t)
+  end
+
+  def count(enumerable) do
+    {:ok, num} = Enumerable.count(enumerable)
+    num
+  end
+
+  def count(enumerable, fun) do
+    {_, acc} = Enumerable.reduce(enumerable, {:cont, 0}, fn(item, acc) ->
+      if fun.(item) do
+        {:cont, acc + 1}
+      else
+        {:cont, acc}
+      end
+    end)
+
+    acc
+  end
+
+  def reduce(enumerable, fun) do
+    {_, result} = Enumerable.reduce(enumerable, {:cont, nil}, fn
+      item, nil ->
+        {:cont, {:acc, item}}
+      item, {:acc, acc} ->
+        {:cont, {:acc, fun.(item, acc)}}
+    end)
+
+    result
+  end
+
+  def reduce(enumerable, acc, fun) do
+    {_, result} = Enumerable.reduce(enumerable, {:cont, acc}, fn
+      item, acc ->
+        {:cont, fun.(item, acc)}
+    end)
+
+    result
+  end
+
+
+  def map(enumerable, fun) do
+    reduce(enumerable, [], fn(x, acc) -> 
+      acc ++ fun.(x)
+    end)
+  end
+
+  def map_reduce(enumerable, acc, fun) do
+    reduce(enumerable, {[], acc}, fn(x, {m, acc}) -> 
+      {v, new_acc} = fun.(x, acc)
+      {m ++ [v], new_acc}
+    end)
+  end
+
+  def each(enumerable, fun) do
+    map(enumerable, fun)
+    :ok
+  end
+
+  def empty?(enumerable) do
+    {:ok, count} = Enumerable.count(enumerable)
+    count == 0
+  end
+
+  def fetch(enumerable, index) do
+    result = Enumerable.reduce(enumerable, {:cont, 0}, fn(item, acc) ->
+      if index == acc do
+        {:halt, {:ok, item}}
+      else
+        {:cont, acc + 1}
+      end
+    end)
+
+    case result do
+      {:cont, _} ->
+        :error
+      {:halt, item} ->
+        item
+    end
+  end
+
+  def fetch!(enumerable, index) do
+    case fetch(enumerable, index) do
+      {:ok, item} ->
+        item
+      :error ->
+        raise Enum.OutOfBoundsError
+    end
+  end
+
+  def filter(enumerable, fun) do
+    reduce(enumerable, [], fn(x, acc) ->
+      if fun.(x) do
+        acc ++ [x]
+      else
+        acc
+      end
+    end)
+  end
+
+  def filter_map(enumerable, filter, mapper) do
+    reduce(enumerable, [], fn(x, acc) ->
+      if filter.(x) do
+        acc ++ [mapper.(x)]
+      else
+        acc
+      end
+    end)
+  end
+
+  def find(enumerable, default \\ nil, fun) do
+    {_, result} = Enumerable.reduce(enumerable, {:cont, default}, fn(item, acc) ->
+      if fun.(item) do
+        {:halt, item}
+      else
+        {:cont, default}
+      end
+    end)
+
+    result
+  end
+
+  def member?(enumerable, value) do
+    {_, result} = Enumerable.reduce(enumerable, {:cont, false}, fn(item, acc) ->
+      if item == value do
+        {:halt, true}
+      else
+        {:cont, false}
+      end
+    end)
+
+    result
+  end
+
+  def drop(enumerable, count) do
+    {_, result} = Enumerable.reduce(enumerable, {:cont, {[], 0}}, fn
+      (item, {taken, drop_count}) ->
+        if drop_count < count do
+          {:cont, {[], drop_count + 1 }}
+        else
+          {:cont, taken ++ [item]}
+        end
+    end)
+
+    result    
+  end
+
+  def drop_while(enumerable, fun) do
+    {_, result} = Enumerable.reduce(enumerable, {:cont, []}, fn
+      (item, taken) ->
+        if fun.(item) do
+          {:cont, {taken}}
+        else
+          {:cont, taken ++ [item]}
+        end
+    end)
+
+    result
+  end
+
+
+  def take(enumerable, count) do
+    if Enumerable.count(enumerable) < count do
+      enumerable
+    else
+      {_, result} = Enumerable.reduce(enumerable, {:cont, {[], 0}}, fn
+        (item, {taken, taken_count}) ->
+          if taken_count == count do
+            {:halt, taken}
+          else
+            {:cont, {taken ++ [item], taken_count + 1}}
+          end
+      end)
+
+      result
+    end
+  end
+
+  def take_every(enumerable, nth) do
+      {_, {result, _count}} = Enumerable.reduce(enumerable, {:cont, {[], 0}}, fn
+        (item, {taken, count}) ->
+          if rem(count, nth) == 0 do
+            {:cont, {taken ++ [item], count + 1}}
+          else
+            {:cont, {taken, count + 1}}
+          end
+      end)
+
+      result
+  end
+
+  def take_while(enumerable, fun) do
+    {_, result} = Enumerable.reduce(enumerable, {:cont, []}, fn
+      (item, taken) ->
+        if fun.(item) do
+          {:cont, {taken ++ [item]}}
+        else
+          {:halt, taken}
+        end
+    end)
+
+    result
+  end
+
+
+  def to_list(enumerable) when is_list(enumerable) do
+    enumerable
+  end
+
+  def to_list(enumerable) do
+    map(enumerable, fn x -> x end)
+  end
+
+  def reverse(enumerable) when is_list(enumerable) do
+    enumerable.concat([]).reverse()
+  end
+
+  def reverse(enumerable) do
+    reduce(enumerable, [], fn(item, acc) ->
+      [item] ++ acc
+    end)
+  end
+
+  def reverse(enumerable, tail) when is_list(enumerable) do
+    enumerable.concat([]).reverse() ++ tail
+  end
+
+  def reverse(enumerable, tail) do
+    result = reduce(enumerable, [], fn(item, acc) ->
+      [item] ++ acc
+    end)
+
+    result ++ tail
+  end
+
+end
diff --git a/priv/std_lib/enum/out_of_bounds_error.ex b/priv/std_lib/enum/out_of_bounds_error.ex
@@ -0,0 +1,3 @@
+defmodule ElixirScript.Enum.OutOfBoundsError do
+  defexception message: "out of bounds error"
+end
diff --git a/priv/std_lib/enumerable.ex b/priv/std_lib/enumerable.ex
@@ -7,10 +7,10 @@ end
 
 defimpl ElixirScript.Enumerable, for: List do
   def count(list),
-    do: length(list)
+    do: {:ok, length(list) }
 
   def member?(list, value),
-    do: value in list
+    do: {:ok, value in list }
 
   def reduce(_,       {:halt, acc}, _fun),   do: {:halted, acc}
   def reduce(list,    {:suspend, acc}, fun), do: {:suspended, acc, &reduce(list, &1, fun)}

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+defmodule ElixirScript.Enum.OutOfBoundsError do`
	`2`	`+ defexception message: "out of bounds error"`
	`3`	`+end`