update 19 files and delete 1 file [deploy]

Author: devidw

.github/workflows/deploy.yml

@@ -2,9 +2,13 @@ name: Deploy
 
 on:
   workflow_dispatch:
+  push:
+    branches:
+      - main
 
 jobs:
   deploy:
+    if: github.event_name == "workflow_dispatch" || contains(github.event.head_commit.message, '[deploy]')
     runs-on: ubuntu-latest
     steps:
       - name: Checkout

.vscode/settings.json

@@ -1,3 +1,3 @@
 {
-  "unocss.root": "site"
+  "unocss.root": "apps/site"
 }

apps/site/README.md

@@ -13,6 +13,7 @@
   },
   "dependencies": {
     "@astrojs/svelte": "^1.0.2",
+    "@fontsource/noto-serif": "^4.5.11",
     "@unocss/reset": "^0.46.1",
     "ace-builds": "^1.12.4",
     "adoc-skin": "^0.1.1",

apps/site/package.json

@@ -0,0 +1 @@
+- how can we force reload files on dev server?

apps/site/readme.adoc

@@ -4,15 +4,15 @@
   let links = [
     {
       label: "Previous",
-      href: $challenge?.page.previous,
+      href: `/${$challenge?.page.previous}`,
     },
     {
       label: "~",
-      href:"/",
+      href: "/",
     },
     {
       label: "Next",
-      href: $challenge?.page.next,
+      href: `/${$challenge?.page.next}`,
     },
   ]
 </script>

apps/site/src/components/Nav.svelte

@@ -1,5 +1,6 @@
 <script lang="ts">
-  import "../styles/adoc.scss"
+  // import "../styles/adoc.scss"
+  import "../styles/doc.styl"
 
   export let title: string | undefined = undefined
   export let value: string

apps/site/src/components/Text.svelte

@@ -54,6 +54,8 @@ export async function getChallenge(slug: string): Promise<Challenge> {
     slug,
     title: readme.getTitle() || slug,
     content: readme.convert(),
+    // title: slug,
+    // content: slug,
     todo,
     main,
     test,

apps/site/src/lib/challenges.ts

@@ -0,0 +1,28 @@
+@import "@fontsource/noto-serif/latin-400.css"
+@import "@fontsource/noto-serif/latin-400-italic.css"
+@import "@fontsource/noto-serif/latin-700.css"
+@import "@fontsource/noto-serif/latin-700-italic.css"
+
+.challenge__prompt
+  @apply space-y-4 text-gray-1
+
+  font-family "Noto Serif"
+  font-size 17px
+  line-height 1.5
+
+  text-rendering optimizeLegibility
+  font-smooth always
+  -webkit-font-smoothing antialiased
+  -moz-osx-font-smoothing grayscale
+  
+  & > .paragraph
+    width 96%
+    @apply mx-auto
+  
+  pre.highlight
+    @apply text-gray-4 rounded-lg px-6 py-4 border-(1 dark-1)
+    background-color #1D1F21
+
+  :not(pre) > code
+    @apply text-gray-4 rounded-lg px-2 py-1 border-(1 dark-1)
+    background-color #1D1F21

apps/site/src/styles/doc.styl

@@ -0,0 +1,5 @@
+actor class Some() {
+  public func a() : async Bool {
+    return true;
+  };
+};

challenges/actors/main.mo

@@ -0,0 +1,78 @@
+= Actors
+
+== Internet Computer
+
+- Canisters are memory isolated
+- Canisters can communicate with asynchronous messages
+- Canisters messenge candid values, the values are binary encoded
+- Canisters only process one message at a time, others wait
+- Canisters use callbacks to register code that needs to be done on given
+message processing
+
+== Motoko
+
+=== General
+
+- Actors are an abstraction/representation for canisters
+- The type of the actor is its functions
+- Its asynchronous functions indicate which messanges can be handled
+- Types of an actor and its functions can be translated to candid
+- The candid types define how the binary data passed is structured
+
+=== Actors vs Objects
+
+We can think of actors like sorts of objects. But there are notable differences:
+
+- Actors come with completely isolated state
+- Any interactivity with the outside goes through asynchronous messanges
+- Messages are processed one-at-a-time, no matter if issued in parallel
+
+=== Motoko Implementation
+
+- Message sending in Motoko means calling an async function of an actor
+- There is no blocking in the wait for the response, istead there is a
+promise/future, that is return to the caller by the callee, that resolves, once
+the message is handled
+- The promise/future is a placeholder, which can result in a result
+- Because there is no blocking in the time waiting for the promise to resolve,
+the caller can do anything, send other requests to any actor or whatever
+- The caller can wait for the result, when it resolves it will be available,
+otherwise its resolved value is stored for future access
+
+=== Shared functions and state
+
+- Actor messanging functions are called _shared_-functions, since they can be
+accessed from remote code, actors, etc.
+- Shared functions return futures/promises that resolve once handled by the
+called actor
+- The data transmitted is immutable, we call it _shared_-state
+
+[source,motko]
+----
+actor {
+  public shared func someFuncName() : async Text {
+    return "I am some func returning some string"
+  }
+}
+----
+
+Since all functions of an actor have to be shared, we can obmit the `shared`
+keyword:
+
+[source,motko]
+----
+actor {
+  public shared func someFuncName() : async Text {
+    return "I am some func returning some string"
+  }
+}
+----
+
+---
+
+// Questios:
+
+- Can multiple messanges we processed by one actor at the same time so the
+one-action-per-time only applies to one messange handler
+  - Or does it apply to the whole actor and therfore only one messange can be
+  called at one time

challenges/actors/readme.adoc

@@ -0,0 +1,5 @@
+actor class Some() {
+  public func a() : async Bool {
+    return true;
+  };
+};

challenges/actors/solution.mo

@@ -0,0 +1,8 @@
+import Main "./main";
+
+module {
+  public func testWithoutShared() : async Bool {
+    let some = await Main.Some();
+    return (await some.a()) == true;
+  };
+};

challenges/actors/test.mo

@@ -0,0 +1,3 @@
+Run the code to see the tests passing.
+
+Remove the optional `shared` function modifier and see the tests still passing.

challenges/actors/todo.adoc

@@ -0,0 +1,9 @@
+actor class Some() {
+  public shared func a() : async Bool {
+    return true;
+  };
+  public shared func b() : async Bool {
+    let aValue = a();
+    return aValue;
+  };
+};

challenges/await/main.mo

@@ -0,0 +1,30 @@
+= Await
+
+Asynchronous functions return promises, that resolve to a value, once it is
+available.
+
+We can store a promise in a variable and then wait for it later:
+
+[source,motoko]
+----
+let a = someAsyncFunc();
+let aResolved = await a;
+----
+
+In the above example `a` holds the promise and `aResolved` waits for the promise
+to resolve and stores the resolved value.
+
+Commonly this is done in one go:
+
+[source,motoko]
+----
+let aResolved = await someAsyncFunc();
+----
+
+If we want to wait for the result of a promise in an expression that is not a
+declaration, we can wrap the awaiting into brackets:
+
+[source,motoko]
+----
+let isTrue = (await someAsyncFunc()) == true;
+---- 

challenges/await/readme.adoc

@@ -0,0 +1,9 @@
+actor class Some() {
+  public shared func a() : async Bool {
+    return true;
+  };
+  public shared func b() : async Bool {
+    let aValue = await a();
+    return aValue;
+  };
+};

challenges/await/solution.mo

@@ -0,0 +1,8 @@
+import Main "./main";
+
+module {
+  public func testAwait() : async Bool {
+    let some = await Main.Some();
+    return (await some.b()) == true;
+  };
+};

challenges/await/test.mo

@@ -0,0 +1,5 @@
+Note that we are returning a promise in a function, that should return a boolean.
+
+Run the source as-is and see the compiler throws an exception.
+
+Fix the function to actually return a boolean value.

challenges/await/todo.adoc

@@ -0,0 +1,6 @@
+actor class Slang(_slang : Text) {
+  var slang : Text = _slang;
+  public func getSlang() : async Text {
+    return slang;
+  };
+};

challenges/classes/main.mo

@@ -0,0 +1 @@
+= Classes

challenges/classes/readme.adoc

@@ -0,0 +1,9 @@
+import Main "./main";
+
+module {
+  public func testConstructor() : async Bool {
+    let someObj = await Main.Slang("Some string");
+    let out = await someObj.getSlang();
+    return out == "Some string";
+  };
+};

challenges/classes/solution.mo

@@ -2,20 +2,20 @@
 
 Motoko comes with 3 different kinds of comments:
 
-== Single line comments
+Single line comments:
 
 ```motoko 
 // single line comment
 ```
 
-== Multi-line comments
+Multi-line comments:
 
 ```motoko 
 /* multi-line 
    comment */
 ```
 
-== Documentation comments
+Documentation comments:
 
 ```motoko 
 /// documentation comment

challenges/classes/test.mo

@@ -1,12 +1,15 @@
 #!/bin/bash
 
-folder=$1
+topic=$1
 
-if [ -z "$folder" ]; then
-    echo "Usage: $0 <folder>"
+if [ -z "$topic" ]; then
+    echo "Usage: $0 <topic>"
     exit 1
 fi
 
-cp -r ./chl-tpl ./challenges/$folder
+cp -r ./chl-tpl ./challenges/$topic
 
-code ./challenges/$folder/readme.adoc
+# Write the capitalized topic as a headline into the readme.adoc
+echo "= ${topic^}" > ./challenges/$topic/readme.adoc
+
+code ./challenges/$topic/readme.adoc

challenges/classes/todo.adoc

@@ -1,5 +1,5 @@
-module {
-  public func a() : Bool {
+actor class Some() {
+  public func a() : async Bool {
     return true;
   };
 };