mal/ada.2/types-atoms.ads

with Garbage_Collected;
with Types.Mal;

package Types.Atoms is

   type Instance (<>) is new Garbage_Collected.Instance with private;

   --  Built-in functions.
   function Atom  (Args : in Mal.T_Array) return Mal.T;
   function Deref (Args : in Mal.T_Array) return Mal.T;
   function Reset (Args : in Mal.T_Array) return Mal.T;
   function Swap  (Args : in Mal.T_Array) return Mal.T;

   --  Helper for print.
   function Deref (Item : in Instance) return Mal.T with Inline;

private

   type Instance is new Garbage_Collected.Instance with record
      Data : Mal.T;
   end record;
   overriding procedure Keep_References (Object : in out Instance) with Inline;

end Types.Atoms;
ada.2: fix memory leaks with garbage collection. Various simplifications. Cyclic references were never deallocated by reference conuting. Symbols cannot create cyclic structures and are less frequent (one allocation per symbol), keep reference counting for them. This slightly improves performances even though many previous optimizations are removed (environment stack, reuse of memory). Step caching hash of symbols. This does not seem to improve performances. Hashing them instead of ordering them does. Define Repl in the step file instead of globally. Move the eval built-in function from core into the step file. When possible, pass Ada records instead of explicit pointers. In the reader, construct more objects directly as described in the MAL process, reserve the buffer for sequences and maps In eval, iterate on vectors without delegation. The increased complexity was not improving performances. Keep demonstrating Ada type-safe genericity for maps, where iterating outside Types.Maps would be less easy and/or efficient. In quasiquote_list, concatenate in one buffer instead of allocating a list for each element. The buffer may be reallocated behind the curtain, but not once per element anymore. In environments, illustrate tail call optimization when recursion is more readable than a loop. 2019-03-31 20:06:00 +03:00			`with Garbage_Collected;`
			`with Types.Mal;`
Major rewrite, improving style and improving performances. 2019-02-28 00:27:12 +03:00
			`package Types.Atoms is`

ada.2: fix memory leaks with garbage collection. Various simplifications. Cyclic references were never deallocated by reference conuting. Symbols cannot create cyclic structures and are less frequent (one allocation per symbol), keep reference counting for them. This slightly improves performances even though many previous optimizations are removed (environment stack, reuse of memory). Step caching hash of symbols. This does not seem to improve performances. Hashing them instead of ordering them does. Define Repl in the step file instead of globally. Move the eval built-in function from core into the step file. When possible, pass Ada records instead of explicit pointers. In the reader, construct more objects directly as described in the MAL process, reserve the buffer for sequences and maps In eval, iterate on vectors without delegation. The increased complexity was not improving performances. Keep demonstrating Ada type-safe genericity for maps, where iterating outside Types.Maps would be less easy and/or efficient. In quasiquote_list, concatenate in one buffer instead of allocating a list for each element. The buffer may be reallocated behind the curtain, but not once per element anymore. In environments, illustrate tail call optimization when recursion is more readable than a loop. 2019-03-31 20:06:00 +03:00			`type Instance (<>) is new Garbage_Collected.Instance with private;`
Major rewrite, improving style and improving performances. 2019-02-28 00:27:12 +03:00
			`-- Built-in functions.`
			`function Atom (Args : in Mal.T_Array) return Mal.T;`
			`function Deref (Args : in Mal.T_Array) return Mal.T;`
			`function Reset (Args : in Mal.T_Array) return Mal.T;`
Improve conformity with the MAL process, performance and readability. Conformity: Move readline to readline.ads and drop the Interactive_Loop subprogram. Let the main Read and Print functions do input/output. Rename environments.ads to envs.ads (the name of the eval parameter seems more important). Move association of formal and actual parameters to the env "constructor". Use the documentation names whenever possible (especially, make calls to Eval where they are expected and explicit the parameters). Iterate on a NS structure provided by Core, as per the process. Use similar method names for Envs.Ptr and Envs.Closure_Ptr, as the difference is an implementation detail. Performance: Move Map into list methods, swap into atom methods. Pass formal parameters as an array of symbols on the stack, instead of a MAL list. Readability: Replace some one-letter names. Use renamings when the lines become too long. Split Pr_Str in small subprograms. Declare the access to built-in functions in Types.Mal. Consistent names. Move redundant comments into README. 2019-03-06 21:48:51 +03:00			`function Swap (Args : in Mal.T_Array) return Mal.T;`

			`-- Helper for print.`
ada.2: fix memory leaks with garbage collection. Various simplifications. Cyclic references were never deallocated by reference conuting. Symbols cannot create cyclic structures and are less frequent (one allocation per symbol), keep reference counting for them. This slightly improves performances even though many previous optimizations are removed (environment stack, reuse of memory). Step caching hash of symbols. This does not seem to improve performances. Hashing them instead of ordering them does. Define Repl in the step file instead of globally. Move the eval built-in function from core into the step file. When possible, pass Ada records instead of explicit pointers. In the reader, construct more objects directly as described in the MAL process, reserve the buffer for sequences and maps In eval, iterate on vectors without delegation. The increased complexity was not improving performances. Keep demonstrating Ada type-safe genericity for maps, where iterating outside Types.Maps would be less easy and/or efficient. In quasiquote_list, concatenate in one buffer instead of allocating a list for each element. The buffer may be reallocated behind the curtain, but not once per element anymore. In environments, illustrate tail call optimization when recursion is more readable than a loop. 2019-03-31 20:06:00 +03:00			`function Deref (Item : in Instance) return Mal.T with Inline;`
ada.2: spring cleaning before final pull request. Two changes require approval. * The 'do' special becomes a built-in function similar to first. This small change reduces the complexity of eval. The last evaluation cannot benefit from TCO, but the performance change seems invisible. * read/eval/print acts on each item found in the input string, as if they were enclosed with (do ..). The guide does not specify what should happen to text following the first AST, and this change actually simplifies some things (like dealing with zero AST). The read-string built-in function only returns the first AST, as changing this would be much more intrusive. Other changes seem straightforward. Global: * Ada 2020 target assignments (like +=, but more general). * Use Constant_Indexing aspect for sequences, so that they can be indexed in source code like native arrays. * consistency renamings. 'fn' does not include built-in functions, 'function' does. 'list' does not include vectors, 'sequence' does. Move error handling to a separate package. * This simplifies code everywhere else. * Uncaught expressions now report a stack trace. Types: * Count allocations and deallocations, check that counts match. * Share more code between functions and macros. Core: * Replace the Core.Ns function returning an array with a procedure (The intermediate object was preventing the reference counting code from deallocating some unused objects). * Implement Prn with Pr_Str. Printer: * Change the profile so that the caller spares some allocations. Reader: * Share a single buffer of mal values between all recursions. This significantly reduces the stack footprint. Steps: * Fix implementation name (ada.2) in the startup script. * Let environment variables trigger debugging information. 2019-03-17 13:24:03 +03:00
Major rewrite, improving style and improving performances. 2019-02-28 00:27:12 +03:00			`private`

ada.2: fix memory leaks with garbage collection. Various simplifications. Cyclic references were never deallocated by reference conuting. Symbols cannot create cyclic structures and are less frequent (one allocation per symbol), keep reference counting for them. This slightly improves performances even though many previous optimizations are removed (environment stack, reuse of memory). Step caching hash of symbols. This does not seem to improve performances. Hashing them instead of ordering them does. Define Repl in the step file instead of globally. Move the eval built-in function from core into the step file. When possible, pass Ada records instead of explicit pointers. In the reader, construct more objects directly as described in the MAL process, reserve the buffer for sequences and maps In eval, iterate on vectors without delegation. The increased complexity was not improving performances. Keep demonstrating Ada type-safe genericity for maps, where iterating outside Types.Maps would be less easy and/or efficient. In quasiquote_list, concatenate in one buffer instead of allocating a list for each element. The buffer may be reallocated behind the curtain, but not once per element anymore. In environments, illustrate tail call optimization when recursion is more readable than a loop. 2019-03-31 20:06:00 +03:00			`type Instance is new Garbage_Collected.Instance with record`
			`Data : Mal.T;`
			`end record;`
			`overriding procedure Keep_References (Object : in out Instance) with Inline;`
Major rewrite, improving style and improving performances. 2019-02-28 00:27:12 +03:00
			`end Types.Atoms;`