doc: revamp explanation of implicit begin

pkgs/racket-doc/scribblings/guide/begin.scrbl

@@ -34,24 +34,16 @@ tail position with respect to the @racket[begin] form.
 (print-triangle 4)
 ]
 
-Many forms, such as @racket[lambda] or @racket[cond] support a
-sequence of expressions even without a @racket[begin]. Such positions are
-sometimes said to have an @deftech{implicit begin}.
+The @racket[begin] form is special at the top level, at module level,
+or as a @racket[_body] (e.g. of @racket[let] or @racket[lambda];
+see @tech{internal definition} for more details).
+Such @racket[begin] form has a slightly different grammar:
 
-@defexamples[
-(define (print-triangle height)
-  (cond
-    [(positive? height)
-     (display (make-string height #\*))
-     (newline)
-     (print-triangle (sub1 height))]))
-(print-triangle 4)
-]
+@specform[(begin def-or-expr ...)]{}
 
-The @racket[begin] form is special at the top level, at module level,
-or as a @racket[body] after only internal definitions. In those
-positions, instead of forming an expression, the content of
+In those positions, instead of forming an expression, the content of
 @racket[begin] is spliced into the surrounding context.
+The content could contain definitions.
 
 @defexamples[
 (let ([curly 0])
@@ -64,6 +56,22 @@ positions, instead of forming an expression, the content of
 This splicing behavior is mainly useful for macros, as we discuss
 later in @secref["macros"].
 
+The whole @racket[_body] sequence is sometimes said to have an @deftech{implicit begin}.
+The restriction of an @tech{implicit begin} follows the restriction of the @racket[_body] sequence:
+the sequence should end with an expression.
+
+@defexamples[
+(code:comment @#,t{Implicit @racket[begin]})
+(let ()
+  (define num 1)
+  (add1 num))
+(code:comment @#,t{Explicit @racket[begin]})
+(let ()
+  (begin
+    (define num 1)
+    (add1 num)))
+]
+
 @;------------------------------------------------------------------------
 @section{Effects After: @racket[begin0]}
 

pkgs/racket-doc/scribblings/guide/define.scrbl

@@ -194,10 +194,10 @@ equivalent to a @racket[define-values] form with a single @racket[_id].
 
 When the grammar for a syntactic form specifies @racket[_body], then
 the corresponding form can be either a definition or an expression.
-A definition as a @racket[_body] is an @defterm{internal definition}.
+A definition as a @racket[_body] is an @deftech{internal definition}.
 
 Expressions and internal definitions in a @racket[_body] sequence can
-be mixed, as long as the last @racket[_body] is an expression.
+be mixed, as long as the sequence ends with an expression.
 
 For example, the syntax of @racket[lambda] is
 

pkgs/racket-doc/scribblings/reference/syntax.scrbl

@@ -2787,13 +2787,14 @@ For backward compatibility only; equivalent to @racket[syntax-local-introduce].
 @defform*[[(begin form ...)
            (begin expr ...+)]]{
 
-The first form applies when @racket[begin] appears at the top level,
-at module level, or in an internal-definition position (before any
-expression in the internal-definition sequence). In that case, the
+The first form applies when @racket[begin] appears at the @tech{top-level context},
+at @tech{module context}, or in an @tech{internal-definition context}. In that case, the
 @racket[begin] form is equivalent to splicing the @racket[form]s into
 the enclosing context.
+The @tech{internal-definition context} itself is said to have an
+@deftech{implicit begin} of this first form.
 
-The second form applies for @racket[begin] in an expression position.
+The second form applies for @racket[begin] in an @tech{expression context}.
 In that case, the @racket[expr]s are evaluated in order, and the
 results are ignored for all but the last @racket[expr]. The last
 @racket[expr] is in tail position with respect to the @racket[begin]