Skip to content

Instantly share code, notes, and snippets.

Avatar

Eksperimental eksperimental

View GitHub Profile
@eksperimental
eksperimental / typespec_example.ex
Last active Jul 2, 2020
Broken types in Elixir Issue #10140
View typespec_example.ex
# Downloaded from: https://gist.github.com/eksperimental/55f1e207ab5878a668668546f57a3f90
#
# Lists all the types that have the problem reported in
# https://github.com/elixir-lang/elixir/issues/10140
# create an Elixir project, and save this file in lib/typespec_example.ex
# Start IEx with: iex -S mix
# then run: TypespecExample.types()
# and paste the output into the shell.
defmodule TypespecExample do
@eksperimental
eksperimental / gist:701103fc9e723fddc0bfeb757ecb1e7d
Created May 25, 2017
What modules implement the Enumerable and Collectable protocols in Elixir
View gist:701103fc9e723fddc0bfeb757ecb1e7d
Collectable
elixir$ ag "defimpl\s+Collectable" -G ".ex$"
HashDict
lib/elixir/lib/hash_dict.ex
247:defimpl Collectable, for: HashDict do
IO.Stream
lib/elixir/lib/io/stream.ex
35: defimpl Collectable do
File.Stream
@eksperimental
eksperimental / .editorconfig
Last active Feb 25, 2019
.editorconfig for Elixir projects
View .editorconfig
# EditorConfig is awesome: http://EditorConfig.org
# .editorconfig for Elixir projects
# https://git.io/elixir-editorconfig
# top-most EditorConfig file
root = true
[*]
indent_style = space
@eksperimental
eksperimental / record_file.exs
Created Sep 23, 2016
How to parse a text file with pattern matching, and converted to a nested list
View record_file.exs
# 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
eksperimental / guard_helpers.ex
Last active Aug 13, 2016 — forked from christhekeele/guard_helpers.ex
A defguard macro written for Elixir v0.11.something a while back. I don't remember anything breaking at the time. Written for a library that was supposed to help AST transformations, in part by creating guards for particular AST constructs.
View guard_helpers.ex
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
eksperimental / PROPOSAL.md
Last active Aug 11, 2016
## Introducing is_kind/2, and operators: is, is_not, is_any, are, are_not, are_any
View PROPOSAL.md

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.
View enum_slice_bench.exs
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
eksperimental / enum_fetch.ex
Last active Jul 16, 2016
Enum.fetch/2 Optimizations
View enum_fetch.ex
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
eksperimental / 1_enum_fetch_benchmarking_report.md
Last active Jul 6, 2016
Enum.fetch/2 optimization for maps, negative indexes, out of bound indexes, empty enumerables, and enumerables with only one element.
View 1_enum_fetch_benchmarking_report.md

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.
View enum_random_bench.exs
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