Changes in doc/proposals/concurrency/text/basics.tex [fb31cb8:3364962]

File:

• doc/proposals/concurrency/text/basics.tex (modified) (2 diffs)

doc/proposals/concurrency/text/basics.tex

@@ -328 +328 @@
 
 \begin{cfacode}
-thread foo {};
+        thread foo {};
 \end{cfacode}
 
@@ -343 +343 @@
 Obviously, for this thread implementation to be usefull it must run some user code. Several other threading interfaces use a function-pointer representation as the interface of threads (for example \Csharp~\cite{Csharp} and Scala~\cite{Scala}). However, this proposal considers that statically tying a \code{main} routine to a thread superseeds this approach. Since the \code{main} routine is already a special routine in \CFA (where the program begins), it is a natural extension of the semantics using overloading to declare mains for different threads (the normal main being the main of the initial thread). As such the \code{main} routine of a thread can be defined as
 \begin{cfacode}
-thread foo {};
-
-void main(foo & this) {
-        sout | "Hello World!" | endl;
-}
+        thread foo {};
+
+        void main(foo & this) {
+                sout | "Hello World!" | endl;
+        }
 \end{cfacode}
 
 In this example, threads of type \code{foo} start execution in the \code{void main(foo &)} routine, which prints \code{"Hello World!"}. While this thesis encourages this approach to enforce strongly-typed programming, users may prefer to use the routine-based thread semantics for the sake of simplicity. With these semantics it is trivial to write a thread type that takes a function pointer as a parameter and executes it on its stack asynchronously
 \begin{cfacode}
-typedef void (*voidFunc)(int);
-
-thread FuncRunner {
-        voidFunc func;
-        int arg;
-};
-
-void ?{}(FuncRunner & this, voidFunc inFunc, int arg) {
-        this.func = inFunc;
-}
-
-void main(FuncRunner & this) {
-        this.func( this.arg );
-}
+        typedef void (*voidFunc)(int);
+
+        thread FuncRunner {
+                voidFunc func;
+                int arg;
+        };
+
+        void ?{}(FuncRunner & this, voidFunc inFunc, int arg) {
+                this.func = inFunc;
+        }
+
+        void main(FuncRunner & this) {
+                this.func( this.arg );
+        }
 \end{cfacode}