sasa1977

Keybase proof

I hereby claim:

• I am sasa1977 on github.
• I am sasajuric (https://keybase.io/sasajuric) on keybase.
• I have a public key whose fingerprint is F1D6 33EA A754 1F56 947B 1083 FD82 5822 1AE5 C7F8

To claim this, I am signing this object:

sasa1977

defmodule Test do
  @proto_version "1.0"

  def process_options(opts) do
    ["-proto", @proto_version] ++ log_opt ++ process_input_options(opts)
  end

  defp log_opt do
    case :application.get_env(:porcelain, :goon_driver_log) do
      :undefined -> []

sasa1977

defmodule Prime do
  def prime_factors(number) do
    first_divisor =
      div(number, 2)..1
      |> Enum.find(&(rem(number, &1) == 0))

    case first_divisor do
      1 -> [number]
      _ -> prime_factors(div(number, first_divisor)) ++ prime_factors(first_divisor)
    end

sasa1977

defmodule Primes do
  # Basic implementation of an infinite prime generator, as explained at
  # http://www.cs.hmc.edu/~oneill/papers/Sieve-JFP.pdf

  def new do
    %{composites: HashDict.new, current: 2}
  end

  def next(%{composites: composites, current: current} = sieve) do
    case HashDict.get(composites, current) do

sasa1977

defmodule Lambda do
  defmacro l(code) do
    make_fun(arity(code), code)
  end
  
  defmacro l(arity, code) do
    make_fun(arity, code)
  end
  
  defp make_fun(arity, code) do

sasa1977

defmodule Lambda do
  defrecord ParseResponse, code: nil, arity: 0 do
    def new_list, do: new(code: [])

    def push(response, this) do
      this.
        update_arity(max(response.arity, &1)).
        update_code([response.code | &1])
    end
    

sasa1977

defmodule Fp do
  defmodule Company do
    defrecordp :company, employees: HashDict.new
    defrecordp :employee, [:id, :name]
    
    def merge_employee(company(employees: employees), employee(id: employee_id) = employee) do
      company(company, employees: Dict.put(employees, employee_id, employee))   
    end
    
    def new, do: company()

sasa1977

defmodule RecordHelper.DynGenerator do
  defmacro __using__(_) do
    generate_macros
  end

  defp generate_macros do
    Enum.map(1..20, fn(i) -> def_macro(args(i)) end)
  end

  defp def_macro(args) do

sasa1977

defrecord LazySeq, [:state, :generator, :limit, {:step, 0}] do
  def next(LazySeq[] = current) do
    {value, new_state} = current.generator.(current.state)
    {value, current.state(new_state).update_step(&1 + 1)}
  end
end


defimpl Enum.Iterator, for: LazySeq do
  def count(LazySeq[] = lseq), do: lseq.limit

sasa1977

defmodule MyLc do
  def next({_, :stop}, _), do: []
  
  def next([], _), do: []
  
  def next([current | next], fun) do
    [fun.(current) | next(next, fun)]
  end
  
  def next({iter, {current, next}}, fun) do