查看“︁Richard Markup v3 帮助文档”︁的源代码

{{不完整}}
{{Info|color=#9dc|此版本的Richard Markup没有实际实现。}}

Richard Markup是我设计的一门带逻辑和流程控制的文本标记语言。相比v2，Richard Markup v3 彻底抛弃了XML标签语法的遗留，逻辑与文本平起平坐，不再依附于元素。

== 基本语法 ==

文件的开头是'''头部信息'''，记录了文件格式的版本（<code>v3</code>）和程序应该运行的环境（<code>soullc</code>――灵魂实验室控制台）：

<pre>&lt;?richard-markup v3 for soullc?&gt;</pre>
随后是若干个'''函数定义'''。实际运行的内容都要写在函数里面，程序启动时会自动调用名为<code>main</code>的函数。一个简单的<code>main</code>函数写成这样：

<pre>|def main:
    Hello, world!</pre>
<code>main</code>函数一般是一个'''块状函数'''，在函数名后用''冒号''表示内容开始。与Python类似，Richard Markup v3使用缩进来表示代码块。

此外，还有一种'''行内函数'''，它不用冒号表示内容开始，而是写在两个<code>`</code>之间，且不能换行，如：

<pre>|def an_inline_function `Hello, world!`</pre>
函数也可以有'''参数'''，后文会讲到。

与Python不同的是，我们的函数内部的内容默认是'''文本'''，运行时会直接输出出来，例如：

<pre>|def main:
    Hello, world!
    Hello, Roy!
    Hello, Richard!
    Hello, everybody!</pre>
以上代码只会输出四行文本；不过，我们可以在文本中嵌入'''逻辑'''。逻辑可分为'''块状逻辑'''和'''行内逻辑'''两种：

<pre>|def main:
    块状逻辑：
    |print 1+2
    行内逻辑：
    1 + 2 = {print 1+2}</pre>
以<code>|</code>开头的是块状逻辑，写在<code>{}</code>中的是行内逻辑。行内逻辑是用来在一行文本中间的某个位置添加逻辑的；其他情况下一般使用块状逻辑，它不能和文本写在同一行。<code>print</code>语句用来在逻辑里输出数据。以上代码应输出：

<pre>块状逻辑：
3
行内逻辑：
1 + 2 = 3</pre>
可以用<code>#</code>来表示'''注释'''，在文本、块状逻辑中，乃至函数外面和函数声明的第一行都可以。不同的是，在文本中注释必须独占一行，而其他地方也可以是在一行正常代码的末尾。

<pre># 一条没有用的注释
|def main: # 主函数
    # Part 1
    Lorem ipsum dolor sit amet.
    这个不是注释：#Hashtag
    |print 114514 # 臭块状逻辑</pre>
== 字面量 变量 ==

可以使用数字、布尔值、字符串、列表等字面量，写法与Python一致：

<pre>|def main:
    |print 1
    |print 1.25
    |print True
    |print False
    |print None
    |print &quot;Hello, world!&quot;
    |print '&quot;Hello&quot;'
    |print [1, 2, 3]</pre>
以上程序输出：

<pre>1
1.25
True
False
None
Hello, world!
&quot;Hello&quot;
[1, 2, 3]</pre>
仍然与Python类似，我们可以创建变量：

<pre>|def main:
    |a = 114514
    |a += 1919810
    |print a</pre>
== 文本字面量 ==

有时我们还需要在逻辑中引用文本。文本和字符串是不同的，因为文本可以设置属性（在<code>soullc</code>中可以设置字体颜色），也可以在里面嵌入逻辑（禁止套娃！）。

与前面讲的函数相同，'''文本字面量'''也分块状和行内，块状也用冒号，行内也用两个<code>`</code>表示：

<pre>|def main:
    |print:
        Hello, world!
        Hello, Roy!
    |print `Hello.`
    {print `Hi`}
    |print:
        |print:
            |print:
                |print:
                    禁止套娃！</pre>
输出：

<pre>Hello, world!
Hello, Roy!
Hello.
Hi
禁止套娃！</pre>
直到文本被<code>print</code>时，它里面的逻辑才会执行。在这个例子中，文本被直接<code>print</code>出来了，<s>跟直接写没什么区别</s>。一般的用法是把文本赋值给变量，或作为参数传递。

<pre>|def main:
    |a = :
        Richard的XP系统是[数据删除]！
    |print a
    |print a
    |print a
    重要的事情说三遍（迫真</pre>
注意，在行内逻辑中没有办法添加块状文本；在行内逻辑中尝试<code>print</code>一个块状内容或调用块状函数都会引发错误。

<pre>|def main:
    |a = :
        一个块状文本
    {print a}（会出错）</pre>
== 多行块状逻辑 ==

如果列表字面量或形参（调用函数时传入的参数）列表中有块状文本字面量，或是因为其他原因需要换行，可以这样写：

<pre>|def main:
    |list = [
        1, 2, 3
        4, 5, 6
        7, 8, 9
    ]</pre>
也就是说，每行的最后一个元素后都不写逗号。这样设计是因为块状文本字面量纯粹使用缩进来表示在哪结束，不方便在它后面写逗号：

<pre>|def main:
    |list = [
        :
            一个块状文本字面量
        :
            另一个块状文本字面量
        &quot;一个字符串&quot;, 1919
    ]
    list中有两个块状文本、一个字符串、一个数字。</pre>
与Python不同，一旦列表字面量/形参列表跨多行，里面的内容就必须缩进一层。不过，普通的和多行的列表字面量/形参列表可以相互包含：

<pre>|def main:
    |function_with_parameters(
        &quot;这是第一个参数&quot;
        [1, [
            &quot;包含很长很长很长很长很长很长很长很长很长很长的字符串的列表字面量也应该使用多行写法&quot;
            &quot;水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水&quot;
        ], 2, 3]
    )</pre>
== 文本的属性 ==

还可以给文本设置属性，方法是在它前面加<code>~</code>，后面跟需要的属性，语法类似于Python中的命名参数。在<code>soullc</code>环境下，可以添加<code>color</code>和<code>bgcolor</code>属性：

<pre>|def main:
    |print ~color=&quot;red&quot;, bgcolor=&quot;#114514&quot;:
        Hello, world!</pre>
这种方法也可以用于整个函数，只要写在<code>:</code>或<code>`</code>前即可。

<pre>|def main ~color=&quot;green&quot;:
    整个程序都是绿的！</pre>
这里的<code>&quot;red&quot;</code>和<code>&quot;#114514&quot;</code>等都是字符串；实际上，也可以用变量来当属性的值。<code>soullc</code>中可用的属性：

{|class=wikitable
! 属性
! 含义
! 可能的值
! 默认值
|-
| <code>color</code>
| 字体颜色
| 0~15的整数，或CSS颜色值字符串
| 空字符串
|-
| <code>bgcolor</code>
| 文字背景高亮颜色
| 0~15的整数，或CSS颜色值字符串
| 空字符串
|-
| <code>pause</code>
| （仅块状文本）换行前是否等待用户按任意键
| 布尔值
| <code>True</code>
|-
| <code>delay</code>
| 每显示一个字符后延时的毫秒数
| 自然数
| <code>45</code>
|}

== 运算符 ==

Richard Markup v3中的运算符有（运算顺序由先到后）：

# 索引和函数调用――<code>a[b]</code>、<code>a( )</code>，左结合
# 乘方――<code>a**b</code>，右结合
# 正负――<code>+a</code>、<code>-a</code>，右结合
# 乘除――<code>a * b</code>、<code>a / b</code>、<code>a // b</code>、<code>a % b</code>，左结合
# 加减――<code>a + b</code>、<code>a - b</code>，左结合
# 比较――<code>a == b</code>、<code>a &lt; b</code>、<code>a &lt;= b</code>、<code>a &gt; b</code>、<code>a &gt;= b</code>、<code>a != b</code>，无结合
# 逻辑非――<code>not a</code>，右结合
# 逻辑与――<code>a and b</code>，左结合
# 逻辑或――<code>a or b</code>，左结合

这些运算符的结合律都与Python相同。''左结合''即<code>a + b + c</code>会按<code>(a + b) + c</code>计算；''右结合''即<code>a**b**c</code>会按<code>a**(b**c)</code>计算；''无结合''即<code>a &lt; b &lt; c</code>会按<code>(a &lt; b) and (b &lt; c)</code>计算。

赋值操作不是运算符，一个赋值操作就是一个语句。赋值操作有：

<pre>= += -= *= /= //= %= **=</pre>
没有<code>++</code>和<code>--</code>，和Python一样，<code>++a</code>只是<code>+(+a)</code>。

没有逗号运算符，所以不可以写：

<pre>|def main:
    |a, b = 1, 2 # 逗号无效</pre>
不过可以用''分号''来在一行写两个语句：

<pre>|def main:
    |a = 1; b = 2</pre>
== 函数参数 [WIP] ==

函数参数的写法与Python基本相同，只是没有参数的函数定义可以省略括号。

<pre>|def function_with_parameter(param):
    # ...</pre>
通过给参数指定默认值可以把它变成一个可选参数，可选参数必需排在最后：

<pre>|def function_with_parameters(param1, param2=&quot;默认值&quot;):
    # ...</pre>
== 流程控制 ==

在块状逻辑中，<code>if</code>――<code>elif</code>――<code>else</code>块这样表示：

<pre>|def main:
    |score = 2**25 # 假设得分是2的25次方（
    #
    |if score &gt;= 60000000:
        您六千万分了
    |elif score &gt;= 30000000:
        您三千万分了
    |else:
        您没到三千万分（）</pre>
行内写法则需要把“冒号加缩进”改成两个<code>`</code>：

<pre>|def main:
    |beers = 2
    {if beers == 0 `No` else `{print beers}`} bottle{if beers &gt; 1 `s`} of beer on the wall.</pre>
也有<code>for</code>循环，但是没有<code>range</code>；要循环指定次数只能用<code>while</code>手动实现，<code>for</code>只能遍历列表。

<pre>|def main:
    |for i in [1, 2, 3]:
        |print i
    
    |i = 1
    |while i &lt;= 3:
        |print i
        |i += 1
    
    |i = 1
    {while i &lt;= 3 `{print i; i += 1}`}</pre>
以下是经典的“FizzBuzz”程序：

<pre>|def main:
    |a = 1
    |while a &lt;= 100:
        |modThree = a % 3
        |modFive = a % 5
        |if modThree != 0 &amp;&amp; modFive != 0:
            |print a
        |else:
            {if modThree == 0 `Fizz`; if modFive == 0 `Buzz`}
        |a += 1</pre>