Merge pull request #20 from clojure-emacs/remove-parseedn

Remove parseedn files

Author: plexus

DESIGN.md

@@ -1,8 +1,8 @@
 # parseclj Design Goals / Roadmap
 
-parseclj is an Emacs Lisp library for parsing Clojure code and EDN data. It
-supports several input and output formats, all powered by the same shift-reduce
-parser function.
+parseclj is an Emacs Lisp library for parsing Clojure code and [EDN
+data](https://github.com/edn-format/edn). It supports several input and output
+formats, all powered by the same shift-reduce parser function.
 
 This documents describes the design goals for parseclj, and as such may describe features which are not implemented yet.
 
@@ -39,7 +39,7 @@ On the other hand Emacs supports strings/buffers with arbitrary encoding, on the
 
 ## Architecture
 
-The implementation is implemented in three parts: a lexer, a parser, and multiple reducers.
+The implementation is implemented in three parts: a lexer, a parser, and [multiple reducers](#multiple-reducers).
 
 ### Lexer
 
@@ -214,7 +214,17 @@ Unmatched closing delimiter:
 
 In many cases it will be desirable to "fail fast", and raise an error as soon as a syntax error is encountered. A `reduce-branch` function can do so if it wishes by checking its input sequence for raw tokens, and raising an error if any are present.
 
-## EDN vs Clojure
+## Multiple Reducers
+
+While the shift-reduce parser parses input, it reduces parsed values (leafs tokens and collections) using "reducing functions".  These functions are in charge of giving actual meaning to the parsed data.
+
+Currently, there are two sets of reducing functions implemented: one set that reduces parsed values to AST data structures, and another one that reduces to Emacs Lisp values.
+
+The AST reducing functions are part of [`parseclj`](https://github.com/clojure-emacs/parseclj), while the Emacs Lisp reducing functions are separated into a differente package called [`parseedn`](https://github.com/clojure-emacs/parseedn).
+
+To understand why these two set of reducing functions are separated, it's important to look at the difference between EDN and Clojure, and also between Emacs Lisp elements and EDN elements.
+
+### EDN vs Clojure
 
 EDN syntax is a subset of Clojure syntax used for representing data (as opposed to code).
 
@@ -223,7 +233,7 @@ Several constructs that are common in Clojure code are not valid in EDN. This in
 - quoting, syntax quoting, syntax quote splicing, etc.
 - read time evaluation with `#=(,,,)`
 
-## Dealing with tagged literals
+### Dealing with tagged literals
 
 EDN/Clojure syntax is extensible. Values can be prefixed with user-provided tags, which indicates they need to be transformed after reading by a registered handler function.
 
@@ -233,7 +243,7 @@ The EDN parser functions will take an optional tag handler function. This functi
 
 When parsing code to an AST the situation is different, here tags simply become part of the AST, without caring about their semantics.
 
-## Representing EDN as Emacs Lisp values
+### Representing EDN as Emacs Lisp values
 
 See also the section at the top regarding differences between Clojure's data types vs those available in Emacs Lisp.
 
@@ -246,11 +256,11 @@ These are the choices that the edn.el library has made:
 - represent characters as integers, *but* parse `\newline` `\return` `\space` and `\tab` as the symbols `'newline` `'return` etc.
 - parse `true` as `t`, `nil` and `false` as `nil`.
 
-### Differences with EDN.el
+#### Differences with EDN.el
 
 At the moment the `parseedn-*` copy the parsing behavior of edn.el, *except* that the character literals `\newline`, `\return`, `\space`, and `\tab` are parsed to their character code (10, 13, 32, and 9 respectively), instead of to symbols.
 
-## AST
+### AST
 
 An AST (abstract syntax tree) is a tree structure made up of nodes. A node looks like this
 
@@ -274,6 +284,8 @@ Non-leaf nodes contain a list of `:children`.
 
 ## Public API
 
+> Disclaimer: outdated information -- this API has been deprecated in favor of [Alternative Package Layout](#alternative-package-layout), and it's only kept here for historical purposes.
+
 parseclj provides three "parse modes"
 
 - `edn` meant for parsing data, it parses EDN to emacs lisp data
@@ -432,7 +444,7 @@ corresponding type in Emacs. `nil' and `false' form a
 particularly poignant case, both are converted to `nil'.")
 ```
 
-**Package**: parseedn
+**Package**: [parseedn](https://github.com/clojure-emacs/parseedn)
 
 - file: parseedn.el
 

README.md

@@ -1,6 +1,6 @@
 [![Build Status](https://travis-ci.org/clojure-emacs/parseclj.svg?branch=master)](https://travis-ci.org/clojure-emacs/parseclj)
 
-# EDN reader and Clojure parser for Emacs Lisp
+# Clojure parser for Emacs Lisp
 
 `parseclj` is an Emacs Lisp library for parsing Clojure code and [EDN
 data](https://github.com/edn-format/edn). It supports several input and output
@@ -25,12 +25,9 @@ You can just copy-paste this code into your Emacs init file:
 
 ## Usage
 
-`parseclj` is actually a compound of two libraries:
-
-- `parseedn`: An EDN reader that transforms EDN to Emacs Lisp data structures.
-- `parseclj`: A Clojure parser that returns an
-  [AST](https://en.wikipedia.org/wiki/Abstract_syntax_tree) that, for example,
-  given as input `(1 2 [:a :b :c])`, it looks like this:
+`parseclj` contains function that return an
+[AST](https://en.wikipedia.org/wiki/Abstract_syntax_tree) that, for example,
+given as input `(1 2 [:a :b :c])`, it looks like this:
 
 ``` emacs-lisp
 ((:node-type . :root)
@@ -61,7 +58,7 @@ You can just copy-paste this code into your Emacs init file:
                                      (:value . :c))))))))
 ```
 
-In order to use any of them, you first need to require it:
+In order to use any of these functions, you first need to require it:
 
 ```emacs-lisp
 (require 'parseclj)
@@ -71,8 +68,6 @@ In order to use any of them, you first need to require it:
 
 And then you will have the following functions at your disposal:
 
-### parseclj
-
 - `parseclj-parse-clojure` &rest string-and-options
 
     When no arguments, parses Clojure source code into an AST and returns it.
@@ -107,26 +102,6 @@ And then you will have the following functions at your disposal:
 
     Transfrom the given AST into Clojure source code and returns it as a string.
 
-### parseedn
-
-- `parseedn-read`
-
-    Read content from the current buffer as EDN and transforms it into an Emacs
-    Lisp value.
-
-- `parseedn-read-str` str
-
-    Read STR as EDN and transfroms it into an Emacs Lisp value.
-
-- `parseedn-print` datum
-
-    Inserts DATUM as EDN Into the current buffer.  DATUM can be any Emacs Lisp
-    value.
-
-- `parseedn-print-str` datum
-
-    Returns a string containing DATUM as EDN.  DATUM can be any Emacs Lisp
-    value.
 
 ## License
 

benchmark/speed-comparison.el

@@ -29,7 +29,6 @@
 
 (require 'subr-x)
 (require 'parseclj-lex)
-(require 'parseedn)
 
 ;; AST helper functions