Docs and tests

Author: josevalim

lib/elixir/pages/cheatsheets/types-cheat.cheatmd

@@ -36,6 +36,7 @@ not type
 ### Indivisible types
 
 ```elixir
+bitstring()
 binary()
 empty_list()
 integer()
@@ -45,6 +46,8 @@ port()
 reference()
 ```
 
+`binary()` is a subtype of `bitstring()`.
+
 ### Atoms
 
 #### All atoms
@@ -167,24 +170,20 @@ tuple()
 
 #### At least n-element tuples
 
-```
+```elixir
 {binary(), binary(), ...}
 ```
 
 ## Additional types for convenience
 
-#### Aliases
+#### Common aliases
 
 ```elixir
-bitstring() = binary()
 boolean() = true or false
 number() = integer() or float()
 ```
 
-The type system currently does not distinguish between
-binaries and bitstrings.
-
-#### Lists
+#### List aliases
 
 ```elixir
 list() = empty_list() or non_empty_list(term())

lib/elixir/pages/references/gradual-set-theoretic-types.md

@@ -24,6 +24,7 @@ The basic types are:
 ```elixir
 atom()
 binary()
+bitstring()
 empty_list()
 integer()
 float()
@@ -56,7 +57,9 @@ In this section we will cover the syntax of all data types. At the moment, devel
 
 ### Indivisible types
 
-These types are indivisibile and have no further representation. They are: `binary()`, `integer()`, `float()`, `pid()`, `port()`, `reference()`.  For example, the numbers `1` and `42` are both represented by the type `integer()`.
+These types are indivisibile and have no further representation. They are: `binary()`, `bitstring()`, `integer()`, `float()`, `pid()`, `port()`, `reference()`.  For example, the numbers `1` and `42` are both represented by the type `integer()`.
+
+Note the `binary()` type is a subtype of the less frequently used `bitstring()` type, as binaries are bitstrings where the number of bits is divisible by 8.
 
 ### Atoms
 
@@ -148,7 +151,7 @@ That's the same as specifying all lists:
 %{list() => integer() or binary()}
 ```
 
-The supported domain keys are `atom()`, `binary()`, `integer()`, `float()`, `fun()`, `list()`, `map()`, `pid()`, `port()`, `reference()`, and `tuple()`.
+The supported domain keys are `atom()`, `bitstring()`, `binary()`, `integer()`, `float()`, `fun()`, `list()`, `map()`, `pid()`, `port()`, `reference()`, and `tuple()`. In the case of maps, the `bitstring()` domain stores exclusively keys which are not binary. The ones which are `binary()` are stored under the `binary()` domain.
 
 Furthermore, it is important to note that domain keys are, by definition, optional. Whenever you have a `%{integer() => integer()}`and you try to fetch a key, we must assume the key may not exist (after all, it is not possible to store all integers as map keys as they are infinite).
 

lib/elixir/test/elixir/module/types/descr_test.exs

@@ -54,7 +54,7 @@ defmodule Module.Types.DescrTest do
         atom(),
         integer(),
         float(),
-        binary(),
+        bitstring(),
         open_map(),
         non_empty_list(term(), term()),
         empty_list(),
@@ -182,7 +182,6 @@ defmodule Module.Types.DescrTest do
              ) == closed_map(a: union(float(), integer()), b: atom())
 
       # Optimization two: we can tell that one map is a subtype of the other:
-
       assert union(
                closed_map(a: term(), b: term()),
                closed_map(a: float(), b: binary())
@@ -216,8 +215,7 @@ defmodule Module.Types.DescrTest do
                tuple([integer(), atom()])
              ) == tuple([union(float(), integer()), atom()])
 
-      # Optimization two: we can tell that one tuple is a subtype of the other:
-
+      # Optimization two: we can tell that one tuple is a subtype of the other
       assert union(
                tuple([term(), term()]),
                tuple([float(), binary()])
@@ -2489,8 +2487,14 @@ defmodule Module.Types.DescrTest do
 
   describe "to_quoted" do
     test "bitmap" do
+      assert union(pid(), bitstring()) |> to_quoted_string() ==
+               "bitstring() or pid()"
+
       assert union(integer(), union(float(), binary())) |> to_quoted_string() ==
                "binary() or float() or integer()"
+
+      assert difference(bitstring(), binary()) |> union(integer()) |> to_quoted_string() ==
+               "(bitstring() and not binary()) or integer()"
     end
 
     test "none" do

lib/elixir/test/elixir/module/types/expr_test.exs

@@ -2040,10 +2040,10 @@ defmodule Module.Types.ExprTest do
   end
 
   describe "comprehensions" do
-    test "binary generators" do
+    test "bitstring generators" do
       assert typeerror!([<<x>>], for(<<y <- x>>, do: y)) ==
                ~l"""
-               expected the right side of <- in a binary generator to be a binary:
+               expected the right side of <- in a binary generator to be a binary (or bitstring):
 
                    x
 
@@ -2066,7 +2066,7 @@ defmodule Module.Types.ExprTest do
                for(<<i <- if(:rand.uniform() > 0.5, do: x, else: y)>>, do: i)
              ) =~
                ~l"""
-               expected the right side of <- in a binary generator to be a binary:
+               expected the right side of <- in a binary generator to be a binary (or bitstring):
 
                    if :rand.uniform() > 0.5 do
                      x
@@ -2092,14 +2092,14 @@ defmodule Module.Types.ExprTest do
                """
     end
 
-    test "infers binary generators" do
+    test "infers bitstring generators" do
       assert typecheck!(
                [x],
                (
                  for <<_ <- x>>, do: :ok
                  x
                )
-             ) == dynamic(binary())
+             ) == dynamic(bitstring())
     end
 
     test ":into" do

lib/elixir/test/elixir/module/types/integration_test.exs

@@ -240,7 +240,7 @@ defmodule Module.Types.IntegrationTest do
       end
 
       assert itself_arg.(Itself.Atom) == dynamic(atom())
-      assert itself_arg.(Itself.BitString) == dynamic(binary())
+      assert itself_arg.(Itself.BitString) == dynamic(bitstring())
       assert itself_arg.(Itself.Float) == dynamic(float())
       assert itself_arg.(Itself.Function) == dynamic(fun())
       assert itself_arg.(Itself.Integer) == dynamic(integer())
@@ -583,7 +583,8 @@ defmodule Module.Types.IntegrationTest do
                 dynamic(
                   %Date{} or %DateTime{} or %NaiveDateTime{} or %Time{} or %URI{} or %Version{} or
                     %Version.Requirement{}
-                ) or atom() or binary() or empty_list() or float() or integer() or non_empty_list(term(), term())
+                ) or atom() or bitstring() or empty_list() or float() or integer() or
+                  non_empty_list(term(), term())
         """,
         """
             warning: incompatible value given to string interpolation:
@@ -667,7 +668,7 @@ defmodule Module.Types.IntegrationTest do
 
             hint: the Collectable protocol is implemented for the following types:
 
-                dynamic(%File.Stream{} or %HashDict{} or %HashSet{} or %IO.Stream{} or %MapSet{}) or binary() or
+                dynamic(%File.Stream{} or %HashDict{} or %HashSet{} or %IO.Stream{} or %MapSet{}) or bitstring() or
                   empty_list() or non_empty_list(term(), term()) or non_struct_map()
         """,
         """
@@ -684,7 +685,7 @@ defmodule Module.Types.IntegrationTest do
 
             hint: the Collectable protocol is implemented for the following types:
 
-                dynamic(%File.Stream{} or %HashDict{} or %HashSet{} or %IO.Stream{} or %MapSet{}) or binary() or
+                dynamic(%File.Stream{} or %HashDict{} or %HashSet{} or %IO.Stream{} or %MapSet{}) or bitstring() or
                   empty_list() or non_empty_list(term(), term()) or non_struct_map()
         """
       ]
@@ -1567,7 +1568,7 @@ defmodule Module.Types.IntegrationTest do
 
   defp read_chunk(binary) do
     assert {:ok, {_module, [{~c"ExCk", chunk}]}} = :beam_lib.chunks(binary, [~c"ExCk"])
-    assert {:elixir_checker_v4, map} = :erlang.binary_to_term(chunk)
+    assert {:elixir_checker_v5, map} = :erlang.binary_to_term(chunk)
     map
   end
 

lib/elixir/test/elixir/module/types/pattern_test.exs

@@ -552,10 +552,10 @@ defmodule Module.Types.PatternTest do
 
     test "is_binary/1" do
       assert typecheck!([x], is_binary(x), x) == dynamic(binary())
-      assert typecheck!([x], not is_binary(x), x) == dynamic(term())
+      assert typecheck!([x], not is_binary(x), x) == dynamic(negation(binary()))
 
-      assert typecheck!([x], is_bitstring(x), x) == dynamic(binary())
-      assert typecheck!([x], not is_bitstring(x), x) == dynamic(negation(binary()))
+      assert typecheck!([x], is_bitstring(x), x) == dynamic(bitstring())
+      assert typecheck!([x], not is_bitstring(x), x) == dynamic(negation(bitstring()))
     end
 
     test "is_function/2" do

lib/elixir/test/elixir/protocol/consolidation_test.exs

@@ -165,7 +165,7 @@ defmodule Protocol.ConsolidationTest do
 
     defp exports(binary) do
       {:ok, {_, [{~c"ExCk", check_bin}]}} = :beam_lib.chunks(binary, [~c"ExCk"])
-      assert {:elixir_checker_v4, contents} = :erlang.binary_to_term(check_bin)
+      assert {:elixir_checker_v5, contents} = :erlang.binary_to_term(check_bin)
       Map.new(contents.exports)
     end
 

lib/mix/lib/mix/compilers/elixir.ex

@@ -5,7 +5,7 @@
 defmodule Mix.Compilers.Elixir do
   @moduledoc false
 
-  @manifest_vsn 30
+  @manifest_vsn 31
   @checkpoint_vsn 4
 
   import Record