fixup! Add EEP for native records

Author: bjorng

eeps/eep-0079.md

@@ -474,76 +474,70 @@ ETS nor `element/2` will work with native records.
 
 ### Native-record guard BIFs
 
-#### `is_record/2`
+#### `is_record/3`
 
-We define a pseudo-BIF `is_record/2`, which will be translated by
-the compiler to instructions to test whether `Term` is a native
-record.
+The existing `is_record/3` BIF is overloaded to also accept a native record:
 
 ```erlang
-is_record(Term :: dynamic(), #Module:Name) -> boolean().
-is_record(Term :: dynamic(), #Name) -> boolean().
+-spec is_record(Term :: dynamic(), Module :: module(), Name :: atom()) -> boolean();
+               (Term :: dynamic(), Name :: atom(), Arity :: non_neg_integer()) -> boolean().
 ```
 
-The `Module` and `Name` arguments must be atoms.
-
-If `Module` is not given, `Name` must refer to either an imported
-record or to a native record defined in the current module. The compiler
-will issue a diagnostic if no record having name `Name` is neither imported
-nor defined in the current module.
+If `Module` is a module name and `Name` is an atom, the predicate
+returns true if term `Term` is a native-record value with the
+corresponding native-record name and the native-record is visible (via
+export) at the call site.
 
-Examples:
+Example:
 
-```erlang
+```
 -module(misc).
--record #user() {a,b,c}.
-
-is_user(U) when is_record(U, #user) ->
-    true;
-is_user(U) when is_record(U, #some_module:other_user) ->
-    true;
-is_user(_U) ->
-    false.
+is_user(U) -> is_record(U, some_module, user).
 ```
 
-<!-- -->
+#### `is_record/2`
+
+The existing `is_record/2` function is extended to also work on native
+records:
 
 ```erlang
--module(example).
--import_record(misc, [user/0]).
-is_user(U) -> is_record(U, #user).
+is_record(Term :: dynamic(), Name :: atom()) -> boolean().
 ```
 
-> Why not include curly brackets after the record name, for example
-> `is_record(R, #user{})`?
+`Name` must be the name of one of the following:
 
-That would look like a record construction, which it is not.
+* a tuple record
+* a local native record
+* a native record imported using `-import_record()'
 
-An attempt to use the existing `is_record/2` in the following way will
-result in a compilation error:
+When `is_record/2` is used in a guard, `Name` must be a literal atom;
+otherwise, there will be a compilation error. There will be a
+compilation error if `Name` is neither the name of a local record nor
+an imported native record.
 
-```erlang
--module(misc).
--record #user() {a,b,c}.
-is_user(U) -> is_record(U, user).
-```
+If `is_record/2` is used in a function body, `Name` is allowed to be a
+variable.
 
-Rationale: It is preferable to only having one syntax for testing for a
-native. Therefore, the `#` is required. In practice, when migrating old
-code, it is better to use pattern matching to test for a record:
+Examples:
 
 ```erlang
 -module(misc).
 -record #user() {a,b,c}.
 
-is_user(#user{}) ->
-    true;
-is_user(#some_module:other_user{}) ->
+is_user(U) when is_record(U, user) ->
     true;
 is_user(_U) ->
     false.
 ```
 
+<!-- -->
+
+```erlang
+-module(example).
+-import_record(misc, [user/0]).
+is_user(U) -> is_record(U, user).
+```
+
 #### `is_record/1`
 
 ```erlang