eksperimental

#!/bin/sh

# make-test-file
# https://git.io/make-test-file
#
# DESCRIPTION:
# make-test-file is a script to ease development of the Elixir programming code
# base. Allowing the developer to run selected tests.
#
# INTRODUCTION:

eksperimental

defmodule ForLoop do
  @doc ~S"""
  Iterates over `term`, while `condition` between `term` and `final` is truthy,
  applying `fun`. It returns the accumulated terms.

    - `term` is any that will be iterated over.
    - `final_term` is the element that will be run against `term` in `condition`.
    - `condition` can take 1 argument: `term`, or two arguments: `term` and `final`.
    - `fun` is run every time a `condition` is evaluated to truthy. 
    - `transform` is applied to `term` at the end of every loop, before the next iteration.

eksperimental

defmodule EnumRandomOriginal do
  def random(enumerable) do
    case Enum.take_random(enumerable, 1) do
      [] -> raise Enum.EmptyError
      [e] -> e
    end
  end
end

defmodule EnumRandomNew do

eksperimental

Optimize Enum.fetch/2 for maps, negative indexes, out of bound indexes, empty enumerables, and enumerables with only one element.

This function has been highly-optimized, through thorough benchmarking.

There were serious issues when dealing with big lists and maps when an out of bound or a negative index was given. Ex. fetching an out-of-bound index in a 1,000-element map, was reduced to 0.18% of the original item. Or same case with a 1,000-element list time was reduced to a 10,5%.

• Enumerables are no longer reversed when dealing with negative indexes.

eksperimental

defmodule EnumFetchHelpers do
  ## fetch

  def fetch_list([], _index),
    do: :error
  def fetch_list([head | _], 0),
    do: {:ok, head}
  def fetch_list([_ | tail], index),
    do: fetch_list(tail, index - 1)

eksperimental

defmodule Data do
  @slice_counts [0, 1, 100, 990, ]

  @terms [
          :range, :range_single, :range_big, :range_huge,
          :list, :list_empty, :list_single, :list_big, :list_huge,
          :map, :map_empty, :map_single, :map_big, :map_huge,
          :struct, :struct_empty, :struct_single, :struct_big, :struct_huge,
         ]

eksperimental

Introducing is_kind/2, and operators: is, is_not, is_any, are, are_not, are_any

Guards clauses are a key feature in Elixir. Researching how to make it easier for developers to define guards, has led me to two enhancement proposal. This is the first one, which will allow developers to write guards, guard-safe macros and regular expressions in a more natural and succinct way.

TLDR;

The following macro is allowed in guards:

• is_kind(term, kind) determines if a given term is of a certain kind.

as well as the following operators:

• term is kinds determines if term is each kind in kinds.

eksperimental

defmodule Guard.Helpers do

  @moduledoc """
  Tools for creating custom guards.
  """

  @doc """
  Creates a macro that's aware of its presence in a guard.
  
  Taken from https://github.com/elixir-lang/elixir/blob/df8b216357e023e4ef078be396fed6b873d6a938/lib/elixir/lib/kernel.ex#L1601-L1615,

eksperimental

# https://elixirforum.com/t/newbie-needs-help-parsing-a-file/1762
defmodule RecordFile do
  def read(file) do
    {:ok, data} = File.read(file)
    
    data
    |> String.split("\n")
    |> filter
  end

eksperimental

# EditorConfig is awesome: http://EditorConfig.org

# .editorconfig for Elixir projects
# https://git.io/elixir-editorconfig

# top-most EditorConfig file
root = true

[*]
indent_style = space