Rename to Project Mentat (docs).

CONTRIBUTING.md

@@ -1,4 +1,4 @@
-# How to contribute to Datomish
+# How to contribute to Project Mentat
 
 This project is very new, so we'll probably revise these guidelines. Please
 comment on a bug before putting significant effort in, if you'd like to
@@ -29,10 +29,10 @@ Signed-off-by: Random J Developer <random@developer.example.org>
 
 ## Example
 
-* Fork this repo at [github.com/mozilla/datomish](https://github.com/mozilla/datomish#fork-destination-box).
+* Fork this repo at [github.com/mozilla/mentat](https://github.com/mozilla/mentat#fork-destination-box).
 * Clone your fork locally. Make sure you use the correct clone URL.
 ```
-git clone git@github.com:YOURNAME/datomish.git
+git clone git@github.com:YOURNAME/mentat.git
 ```
 Check your remotes:
 ```
@@ -40,7 +40,7 @@ git remote --verbose
 ```
 Make sure you have an upstream remote defined:
 ```
-git remote add upstream https://github.com/mozilla/datomish
+git remote add upstream https://github.com/mozilla/mentat
 ```
 
 * Create a new branch to start working on a bug or feature:

README.md

@@ -1,15 +1,15 @@
-# Datomish
+# Project Mentat
 
-Datomish is a persistent, embedded knowledge base. It draws heavily on [DataScript](https://github.com/tonsky/datascript) and [Datomic](http://datomic.com).
+Project Mentat is a persistent, embedded knowledge base. It draws heavily on [DataScript](https://github.com/tonsky/datascript) and [Datomic](http://datomic.com).
 
-The first version of Datomish [was written in ClojureScript](https://github.com/mozilla/datomish/tree/master), targeting both Node (on top of `promise_sqlite`) and Firefox (on top of `Sqlite.jsm`). It also works in pure Clojure on the JVM on top of `jdbc-sqlite`.
+The first version of Project Mentat, named Datomish, [was written in ClojureScript](https://github.com/mozilla/mentat/tree/master), targeting both Node (on top of `promise_sqlite`) and Firefox (on top of `Sqlite.jsm`). It also works in pure Clojure on the JVM on top of `jdbc-sqlite`. The name was changed to avoid confusion with [Datomic](http://datomic.com).
 
-This branch is for rewriting Datomish in Rust, giving us a smaller compiled output, better performance, more type safety, better tooling, and easier deployment into Firefox and mobile platforms.
+This branch is for rewriting Mentat in Rust, giving us a smaller compiled output, better performance, more type safety, better tooling, and easier deployment into Firefox and mobile platforms.
 
 
 ## Motivation
 
-Datomish is intended to be a flexible relational (not key-value, not document-oriented) store that doesn't leak its storage schema to users, and doesn't make it hard to grow its domain schema and run arbitrary queries.
+Mentat is intended to be a flexible relational (not key-value, not document-oriented) store that doesn't leak its storage schema to users, and doesn't make it hard to grow its domain schema and run arbitrary queries.
 
 Our short-term goal is to build a system that, as the basis for a User Agent Service, can support multiple [Tofino](https://github.com/mozilla/tofino) UX experiments without having a storage engineer do significant data migration, schema work, or revving of special-purpose endpoints.
 
@@ -20,9 +20,9 @@ By abstracting away the storage schema, and by exposing change listeners outside
 
 DataScript asks the question: "What if creating a database would be as cheap as creating a Hashmap?"
 
-Datomish is not interested in that. Instead, it's strongly interested in persistence and performance, with very little interest in immutable databases/databases as values or throwaway use.
+Mentat is not interested in that. Instead, it's strongly interested in persistence and performance, with very little interest in immutable databases/databases as values or throwaway use.
 
-One might say that Datomish's question is: "What if an SQLite database could store arbitrary relations, for arbitrary consumers, without them having to coordinate an up-front storage-level schema?"
+One might say that Mentat's question is: "What if an SQLite database could store arbitrary relations, for arbitrary consumers, without them having to coordinate an up-front storage-level schema?"
 
 (Note that [domain-level schemas are very valuable](http://martinfowler.com/articles/schemaless/).)
 
@@ -30,9 +30,9 @@ Another possible question would be: "What if we could bake some of the concepts
 
 Some thought has been given to how databases as values — long-term references to a snapshot of the store at an instant in time — could work in this model. It's not impossible; it simply has different performance characteristics.
 
-Just like DataScript, Datomish speaks Datalog for querying and takes additions and retractions as input to a transaction. Unlike DataScript, Datomish's API is asynchronous.
+Just like DataScript, Mentat speaks Datalog for querying and takes additions and retractions as input to a transaction. Unlike DataScript, Mentat's API is asynchronous.
 
-Unlike DataScript, Datomish exposes free-text indexing, thanks to SQLite.
+Unlike DataScript, Mentat exposes free-text indexing, thanks to SQLite.
 
 
 ## Comparison to Datomic
@@ -41,14 +41,14 @@ Datomic is a server-side, enterprise-grade data storage system. Datomic has a be
 
 Many of these design decisions are inapplicable to deployed desktop software; indeed, the use of multiple JVM processes makes Datomic's use in a small desktop app, or a mobile device, prohibitive.
 
-Datomish is designed for embedding, initially in an Electron app ([Tofino](https://github.com/mozilla/tofino)). It is less concerned with exposing consistent database states outside transaction boundaries, because that's less important here, and dropping some of these requirements allows us to leverage SQLite itself.
+Mentat is designed for embedding, initially in an Electron app ([Tofino](https://github.com/mozilla/tofino)). It is less concerned with exposing consistent database states outside transaction boundaries, because that's less important here, and dropping some of these requirements allows us to leverage SQLite itself.
 
 
 ## Comparison to SQLite
 
 SQLite is a traditional SQL database in most respects: schemas conflate semantic, structural, and datatype concerns; the main interface with the database is human-first textual queries; sparse and graph-structured data are 'unnatural', if not always inefficient; experimenting with and evolving data models are error-prone and complicated activities; and so on.
 
-Datomish aims to offer many of the advantages of SQLite — single-file use, embeddability, and good performance — while building a more relaxed and expressive data model on top.
+Mentat aims to offer many of the advantages of SQLite — single-file use, embeddability, and good performance — while building a more relaxed and expressive data model on top.
 
 ## Contributing
 
@@ -78,7 +78,7 @@ To run tests use:
 cargo test
 
 # Run tests for the query-parser folder
-cargo test -p datomish-query-parser
+cargo test -p mentat-query-parser
 ````
 
 To start the cli use:
@@ -87,15 +87,15 @@ To start the cli use:
 cargo run
 ````
 
-For most `cargo` commands you can pass the `-p` argument to run the command just on that package.  By convention, the package name will be "datomish-directory-name".  So, `cargo build -p datomish-cli` will build just the "cli" folder.
+For most `cargo` commands you can pass the `-p` argument to run the command just on that package.  By convention, the package name will be "mentat-directory-name".  So, `cargo build -p mentat-cli` will build just the "cli" folder.
 
 ## License
 
-Datomish is currently licensed under the Apache License v2.0. See the `LICENSE` file for details.
+Project Mentat is currently licensed under the Apache License v2.0. See the `LICENSE` file for details.
 
 
 ## SQLite dependencies
 
-Datomish uses partial indices, which are available in SQLite 3.8.0 and higher.
+Mentat uses partial indices, which are available in SQLite 3.8.0 and higher.
 
 It also uses FTS4, which is [a compile time option](http://www.sqlite.org/fts3.html#section_2).