The big Motoko renaming PR (#801)

* ActorScript → Motoko
* actorScript → motoko
* `asc` → `.moc`
* `.as` → `.mo`
* `as-ld` → `mo-ld`

…and so on.

Author: nomeata

.gitattributes

@@ -1,2 +1,2 @@
-# .gitattributes file which reclassifies `.as` files as Swift:
-*.as linguist-language=Swift
+# .gitattributes file which reclassifies `.mo` files as Swift:
+*.mo linguist-language=Swift

Building.md

@@ -1,9 +1,9 @@
 ## Installation using Nix
 
-To install the `asc` binary into your nix environment, use
+To install the `moc` binary into your nix environment, use
 
 ```
-$ nix-env -i -f . -A asc
+$ nix-env -i -f . -A moc
 ```
 
 ## Development using Nix
@@ -19,9 +19,9 @@ $ nix-shell
 ```
 within this shell you can run
  * `make` in `src/` to build all binaries,
- * `make asc` in `src/` to build just the `asc` binary,
- * `make DUNE_OPTS=--watch asc` to keep rebuilding as source files are changing
- * `make` in `rts/` to build the ActorScript runtime
+ * `make moc` in `src/` to build just the `moc` binary,
+ * `make DUNE_OPTS=--watch moc` to keep rebuilding as source files are changing
+ * `make` in `rts/` to build the Motoko runtime
  * `make` in `test/` to run the test suite.
 
 This invokes `dune` under the hood, which will, as a side effect, also create
@@ -54,11 +54,11 @@ installing all required tools without nix is out of scope).
    nix-env -i -f . -A wabt
    nix-env -i -f . -A dvm
    ```
- * Building the ActorScript runtime without nix is tricky. But you can run
+ * Building the Motoko runtime without nix is tricky. But you can run
    ```
    nix-shell --run 'make -C rts'
    ```
-   to get `rts/as-rts.wasm`.
+   to get `rts/mo-rts.wasm`.
 
 
 ## Create a coverage report
@@ -71,16 +71,16 @@ https://github.com/ocaml/dune/issues/57 to see when a coverage report is viable
 1. Build with profiling (TODO: How to do with dune)
    ```
    make -C src clean
-   make BUILD=p.native -C src asc
+   make BUILD=p.native -C src moc
    ```
-2. Run `asc` as normal, e.g.
+2. Run `moc` as normal, e.g.
    ```
-   ./src/asc -c foo.as -o foo.wasm
+   ./src/moc -c foo.mo -o foo.wasm
    ```
    this should dump a `gmon.out` file in the current directory.
 3. Create the report, e.g. using
    ```
-   gprof --graph src/asc
+   gprof --graph src/moc
    ```
    (Note that you have to _run_ this in the directory with `gmon.out`, but
    _pass_ it the path to the binary.)

README.md

@@ -1,10 +1,10 @@
-# ActorScript
+# Motoko
 
 A simple language for writing Dfinity actors.
 
 ## User Documentation & Samples
 
-* [Overview slides](https://hydra.dfinity.systems/job/dfinity-ci-build/actorscript/users-guide/latest/download/1/as-slides.html) ([sources](guide/as-slides.md)).
+* [Overview slides](https://hydra.dfinity.systems/job/dfinity-ci-build/motoko/users-guide/latest/download/1/as-slides.html) ([sources](guide/as-slides.md)).
 * [Draft (incomplete) manual](guide/guide.md).
 * [Prelude](src/prelude/prelude.ml).
 * Beginnings of [standard library](stdlib).

ci.nix

@@ -10,8 +10,8 @@ let
 in
 linux // {
   darwin = darwin.all-systems-go;
-  asc-tar-x86_64-darwin = darwin.asc-tar;
-  asc-tar-x86_64-linux = linux.asc-tar;
+  moc-tar-x86_64-darwin = darwin.moc-tar;
+  moc-tar-x86_64-linux = linux.moc-tar;
   all-systems-go = inject-rev (nixpkgs.releaseTools.aggregate {
     name = "all-systems-go";
     constituents = [

default.nix

@@ -201,7 +201,7 @@ in
 
 rec {
   rts = stdenv.mkDerivation {
-    name = "asc-rts";
+    name = "moc-rts";
 
     src = subpath ./rts;
     nativeBuildInputs = [ nixpkgs.makeWrapper ];
@@ -221,56 +221,56 @@ rec {
 
     installPhase = ''
       mkdir -p $out/rts
-      cp as-rts.wasm $out/rts
+      cp mo-rts.wasm $out/rts
     '';
   };
 
-  asc-bin = stdenv.mkDerivation {
-    name = "asc-bin";
+  moc-bin = stdenv.mkDerivation {
+    name = "moc-bin";
 
     src = subpath ./src;
 
     buildInputs = commonBuildInputs;
 
     buildPhase = ''
-      make DUNE_OPTS="--display=short --profile release" asc as-ld
+      make DUNE_OPTS="--display=short --profile release" moc mo-ld
     '';
 
     installPhase = ''
       mkdir -p $out/bin
-      cp --verbose --dereference asc as-ld $out/bin
+      cp --verbose --dereference moc mo-ld $out/bin
     '';
   };
 
-  asc = nixpkgs.symlinkJoin {
-    name = "asc";
-    paths = [ asc-bin rts ];
+  moc = nixpkgs.symlinkJoin {
+    name = "moc";
+    paths = [ moc-bin rts ];
     buildInputs = [ nixpkgs.makeWrapper ];
     postBuild = ''
-      wrapProgram $out/bin/asc \
-        --set-default ASC_RTS "$out/rts/as-rts.wasm"
+      wrapProgram $out/bin/moc \
+        --set-default MOC_RTS "$out/rts/mo-rts.wasm"
     '';
   };
 
-  asc-tar = nixpkgs.symlinkJoin {
-    name = "asc-tar";
-    paths = [ asc-bin rts didc ];
+  moc-tar = nixpkgs.symlinkJoin {
+    name = "moc-tar";
+    paths = [ moc-bin rts didc ];
     postBuild = ''
-      tar -chf $out/asc.tar -C $out bin/asc rts/as-rts.wasm bin/didc
+      tar -chf $out/moc.tar -C $out bin/moc rts/mo-rts.wasm bin/didc
       mkdir -p $out/nix-support
-      echo "file bin $out/asc.tar" >> $out/nix-support/hydra-build-products
+      echo "file bin $out/moc.tar" >> $out/nix-support/hydra-build-products
     '';
   };
 
   lsp-int = haskellPackages.callCabal2nix "lsp-int" test/lsp-int { };
 
-  qc-actorscript = haskellPackages.callCabal2nix "qc-actorscript" test/random { };
+  qc-motoko = haskellPackages.callCabal2nix "qc-motoko" test/random { };
 
   tests = stdenv.mkDerivation {
     name = "tests";
     src = subpath ./test;
     buildInputs =
-      [ asc
+      [ moc
         didc
         deser
         ocaml_wasm
@@ -283,7 +283,7 @@ rec {
         js-user-library
         dvm
         drun
-        qc-actorscript
+        qc-motoko
         lsp-int
         esm
       ] ++
@@ -292,19 +292,19 @@ rec {
     buildPhase = ''
         patchShebangs .
         ${llvmEnv}
-        export ASC=asc
-        export AS_LD=as-ld
+        export MOC=moc
+        export MO_LD=mo-ld
         export DIDC=didc
         export DESER=deser
         export ESM=${esm}
         export JS_USER_LIBRARY=${js-user-library}
-        asc --version
+        moc --version
         make parallel
-        qc-actorscript${nixpkgs.lib.optionalString (replay != 0)
+        qc-motoko${nixpkgs.lib.optionalString (replay != 0)
           " --quickcheck-replay=${toString replay}"}
         cp -R ${subpath ./test/lsp-int/test-project} test-project
         find ./test-project -type d -exec chmod +w {} +
-        lsp-int ${as-ide}/bin/as-ide ./test-project
+        lsp-int ${mo-ide}/bin/mo-ide ./test-project
       '';
 
     installPhase = ''
@@ -328,28 +328,28 @@ rec {
     '';
   };
 
-  as-ide = stdenv.mkDerivation {
-    name = "as-ide";
+  mo-ide = stdenv.mkDerivation {
+    name = "mo-ide";
 
     src = subpath ./src;
 
     buildInputs = commonBuildInputs;
 
     buildPhase = ''
-      make DUNE_OPTS="--display=short --profile release" as-ide
+      make DUNE_OPTS="--display=short --profile release" mo-ide
     '';
 
     installPhase = ''
       mkdir -p $out/bin
-      cp --verbose --dereference as-ide $out/bin
+      cp --verbose --dereference mo-ide $out/bin
     '';
   };
 
   samples = stdenv.mkDerivation {
     name = "samples";
     src = subpath ./samples;
     buildInputs =
-      [ asc
+      [ moc
         didc
         ocaml_wasm
         nixpkgs.wabt
@@ -362,16 +362,16 @@ rec {
 
     buildPhase = ''
         patchShebangs .
-        export ASC=asc
+        export MOC=moc
         make all
       '';
     installPhase = ''
       touch $out
     '';
   };
 
-  js = asc-bin.overrideAttrs (oldAttrs: {
-    name = "asc.js";
+  js = moc-bin.overrideAttrs (oldAttrs: {
+    name = "moc.js";
 
     buildInputs = commonBuildInputs ++ [
       nixpkgs.ocamlPackages.js_of_ocaml
@@ -381,12 +381,12 @@ rec {
     ];
 
     buildPhase = ''
-      make asc.js
+      make moc.js
     '';
 
     installPhase = ''
       mkdir -p $out
-      cp -v asc.js $out
+      cp -v moc.js $out
       cp -vr ${rts}/rts $out
     '';
 
@@ -470,15 +470,15 @@ rec {
     '';
     doCheck = true;
     checkInputs = [
-      asc
+      moc
       nixpkgs.python
     ];
     checkPhase = ''
-      make ASC=${asc}/bin/asc alltests
+      make MOC=${moc}/bin/moc alltests
     '';
     installPhase = ''
       mkdir -p $out
-      tar -rf $out/stdlib.tar -C $src *.as
+      tar -rf $out/stdlib.tar -C $src *.mo
       mkdir -p $out/nix-support
       echo "report stdlib $out/stdlib.tar" >> $out/nix-support/hydra-build-products
     '';
@@ -525,15 +525,15 @@ rec {
     name = "produce-exchange";
     src = subpath ./stdlib;
     buildInputs = [
-      asc
+      moc
     ];
 
     doCheck = true;
     buildPhase = ''
-      make ASC=asc OUTDIR=_out _out/ProduceExchange.wasm
+      make MOC=moc OUTDIR=_out _out/ProduceExchange.wasm
     '';
     checkPhase = ''
-      make ASC=asc OUTDIR=_out _out/ProduceExchange.out
+      make MOC=moc OUTDIR=_out _out/ProduceExchange.out
     '';
     installPhase = ''
       mkdir -p $out
@@ -544,8 +544,8 @@ rec {
   all-systems-go = nixpkgs.releaseTools.aggregate {
     name = "all-systems-go";
     constituents = [
-      asc
-      as-ide
+      moc
+      mo-ide
       js
       didc
       deser
@@ -563,16 +563,16 @@ rec {
 
   shell = if export-shell then nixpkgs.mkShell {
     #
-    # Since building asc, and testing it, are two different derivations in we
+    # Since building moc, and testing it, are two different derivations in we
     # have to create a fake derivation for `nix-shell` that commons up the
     # build dependencies of the two to provide a build environment that offers
-    # both, while not actually building `asc`
+    # both, while not actually building `moc`
     #
 
     buildInputs =
-      let dont_build = [ asc didc deser ]; in
+      let dont_build = [ moc didc deser ]; in
       nixpkgs.lib.lists.unique (builtins.filter (i: !(builtins.elem i dont_build)) (
-        asc-bin.buildInputs ++
+        moc-bin.buildInputs ++
         js.buildInputs ++
         rts.buildInputs ++
         didc.buildInputs ++

design/FAQ.md

@@ -6,7 +6,7 @@ An actor is instantiated as a separate wasm instance, with isolated state. Class
 
 At the moment, anywhere - they get compiled to async message sends to the enclosing (perhaps implicit) actor that return a promise. You might, however, not be able to await the result unless you are in an outer async context! But you could pass in into another async block that can await it.
 
-> 3. What kinds of datatypes are permitted to be declared with the `share` qualifier; and why some but not others (what’s the source of the distinction, and its role in writing actorscript-based systems)
+> 3. What kinds of datatypes are permitted to be declared with the `share` qualifier; and why some but not others (what’s the source of the distinction, and its role in writing motoko-based systems)
 
 Shared means transmittable without losing identity, essentially. So scalars, immutable data, option of shared, shared (immutable objects), shared functions and actor references can be sent/received, but nothing else that might contain or close over mutable state. That's the idea, assuming it isn't broken. Not all restrictions are currently checked (i.e. escape of shared state into actors and shared functions for instance.) Note that serialization is mostly by value, apart from actors and shared functions, which are by reference, so identity can't be preserved for most values, ruling out them containing state.