fix some over-wide lines

Author: michaelballantyne

scribblings/reference/compiling.scrbl

@@ -43,7 +43,9 @@ Here is an example for a @racket[match] DSL where pattern-bound variables cannot
 @;TODO host-interface/expression and racket-expr isn't getting linked
 @racketblock[
 (syntax-spec
- (binding-class pat-var #:reference-compiler (make-variable-like-reference-compiler (lambda (id) id)))
+ (binding-class pat-var
+   #:reference-compiler (make-variable-like-reference-compiler
+                         (lambda (id) id)))
  (host-interface/expression
   (match target:racket-expr c:clause ...)
   #'(let ([target-pv target])

scribblings/tutorial/basic-tutorial.scrbl

@@ -71,7 +71,9 @@ Our initial specification with @racket[syntax-spec] supplies the grammar:
 
     (nonterminal state-spec
       (state name:id transitions:transition-spec ...)
-      (state name:id ((~datum on-enter) body:action-spec ...+) transitions:transition-spec ...))
+      (state name:id
+        ((~datum on-enter) body:action-spec ...+)
+        transitions:transition-spec ...))
 
     (nonterminal transition-spec
       (on (event-name:id arg:id ...)
@@ -196,7 +198,9 @@ Now let's add binding rules for state names. We can't just use @racket[scope] an
     (error 'machine "compiler not yet implemented"))
 
   (nonterminal/exporting state-spec
-    (state name:state-name ((~datum on-enter) body:action-spec ...+)  transition:transition-spec ...)
+    (state name:state-name
+      ((~datum on-enter) body:action-spec ...+)
+      transition:transition-spec ...)
     #:binding (export name)
 
     (state name:state-name transition:transition-spec ...)
@@ -252,7 +256,9 @@ An action expression can only @racket[displayln] the value of a variable. What i
      ...
 
      (nonterminal/exporting state-spec
-       (state name:state-name ((~datum on-enter) body:racket-body ...+)  transition:transition-spec ...)
+       (state name:state-name
+         ((~datum on-enter) body:racket-body ...+)
+         transition:transition-spec ...)
        #:binding [(export name) (scope (import body) ...)]
 
        (state name:state-name transition:transition-spec ...)
@@ -362,11 +368,12 @@ We'll create a class for the state machine, which acts as a context class, and a
 
 The @racket[machine%] class stores the current state instance and delegates to it. Each state class has methods for each defined transition. Transition actions go in the transition's method and @racket[on-enter] actions go in the class body. When a state is entered, the @racket[machine%] class creates a fresh instance of it, which runs the class body, and sets the current state to that instance. Finally, we return an instance of the machine class.
 
-Now Let's start to write the compiler:
+Now let's start to write the compiler:
 
 @racketblock[
 (syntax-spec
-  (binding-class event-var #:reference-compiler mutable-reference-compiler)
+  (binding-class event-var
+    #:reference-compiler mutable-reference-compiler)
   ...
   (host-interface/expression
     (machine #:initial initial-state:state-name s:state-spec ...)
@@ -379,7 +386,8 @@ Now Let's start to write the compiler:
     #:datum-literals (machine state on-enter)
     [(_ initial-state
         (state state-name
-          (~optional (on-enter action ...) #:defaults ([(action 1) '()]))
+          (~optional (on-enter action ...)
+                     #:defaults ([(action 1) '()]))
           e ...)
         ...)
      #'(let ()
@@ -495,8 +503,10 @@ In our language's compiler, we can use symbol set to raise an error when a state
   (define (check-for-inaccessible-states initial-state-id state-specs)
     (define accessible-states (get-accessible-states initial-state-id state-specs))
     (for/list ([state-spec state-specs]
-               #:unless (symbol-set-member? accessible-states (state-spec-name state-spec)))
-      (error 'machine "Inaccessible state: ~a" (syntax->datum (state-spec-name state-spec)))))
+               #:unless (symbol-set-member? accessible-states
+                                            (state-spec-name state-spec)))
+      (error 'machine "Inaccessible state: ~a"
+             (syntax->datum (state-spec-name state-spec)))))
 
   (define (get-accessible-states initial-state-id state-specs)
     (define accessible-states (local-symbol-set))

scribblings/tutorial/multipass-tutorial.scrbl

@@ -17,7 +17,9 @@ Here is the syntax-spec of our language:
 @repl[
 #:hidden #t
 (module grammar racket
-(provide (all-defined-out) (for-space anf (all-defined-out)) (for-syntax (all-defined-out) (for-space anf (all-defined-out))))
+(provide (all-defined-out)
+         (for-space anf (all-defined-out))
+         (for-syntax (all-defined-out) (for-space anf (all-defined-out))))
   (require "main.rkt" (for-syntax syntax/parse racket))
   (require (for-syntax racket/match racket/syntax racket/list))
 (syntax-spec
@@ -80,7 +82,8 @@ Here is the syntax-spec of our language:
     (define bindings-rev '())
     ; Identifier rhs-expr -> Void
     ; ends up producing a let-binding of x to e in the result
-    (define (lift-binding! x e) (set! bindings-rev (cons (list x e) bindings-rev)))
+    (define (lift-binding! x e)
+      (set! bindings-rev (cons (list x e) bindings-rev)))
     (define e^ (to-rhs! e lift-binding!))
     (wrap-lets e^ (reverse bindings-rev)))
 

scribblings/tutorial/stlc-tutorial.scrbl

@@ -253,7 +253,8 @@ Let's do it!
 
 @racketblock[#:escape unracket
 (syntax-spec
-  (binding-class typed-var #:reference-compiler typed-var-reference-compiler)
+  (binding-class typed-var
+    #:reference-compiler typed-var-reference-compiler)
   ...
 
   (nonterminal typed-expr
@@ -478,13 +479,17 @@ Now let's update the rest of our code:
 
 (define-stlc-syntax let
   (syntax-parser
-    [(_ ([x e] ...) body) #'(#%let ([x e] ...) body)]
-    [(_ ([x e] ...) body ...+) #'(#%let ([x e] ...) (block body ...))]))
+    [(_ ([x e] ...) body)
+     #'(#%let ([x e] ...) body)]
+    [(_ ([x e] ...) body ...+)
+     #'(#%let ([x e] ...) (block body ...))]))
 
 (define-stlc-syntax lambda
   (syntax-parser
-    [(_ ([x (~datum :) t] ...) body) #'(#%lambda ([x : t] ...) body)]
-    [(_ ([x (~datum :) t] ...) body ...+) #'(#%lambda ([x : t] ...) (block body ...))]))
+    [(_ ([x (~datum :) t] ...) body)
+     #'(#%lambda ([x : t] ...) body)]
+    [(_ ([x (~datum :) t] ...) body ...+)
+     #'(#%lambda ([x : t] ...) (block body ...))]))
 
 (define-stlc-syntax let*
   (syntax-parser