defprotocol Enumerable do @moduledoc """ Enumerable protocol used by `Enum` and `Stream` modules. When you invoke a function in the `Enum` module,the first argument is usually a collection that must implement this protocol. For example,the expression `Enum.map([1,2,3],&(&1 * 2))` invokes `Enumerable.reduce/3` to perform the reducing operation that builds a mapped list by calling the mapping function `&(&1 * 2)` on every element in the collection and consuming the element with an accumulated list. Internally,`Enum.map/2` is implemented as follows:def map(enumerable,fun) do reducer = fn x,acc ->{:cont,[fun.(x) | acc]}end Enumerable.reduce(enumerable,{:cont,[]},reducer) |> elem(1) |>:lists.reverse() end Note that the user-supplied function is wrapped into a `t:reducer/0` function. The `t:reducer/0` function must return a tagged tuple after each step,as described in the `t:acc/0` type. At the end,`Enumerable.reduce/3` returns `t:result/0`. This protocol uses tagged tuples to exchange information between the reducer function and the data type that implements the protocol. This allows enumeration of resources,such as files,to be done efficiently while also guaranteeing the resource will be closed at the end of

... [truncated 127339 chars] ...

nge,:step,step),value) end def member?(_,_value) do{:ok,false}end def count(range) do{:ok,Range.size(range)}end def slice(first.._//step = range) do{:ok,Range.size(range),&slice(first + &1 * step,step * &3,&2)}end slice = quote generated:true do slice(%{__struct__:Range,first:var!(first),last:var!(last)}= var!(range)) end def unquote(slice) do step = if first<= last,do:1,else:-1 slice(Map.put(range,:step,step)) end defp slice(current,_step,1),do:[current] defp slice(current,step,remaining) when remaining> 1 do [current | slice(current + step,step,remaining - 1)] end end