Scheme 方案-逻辑运算符程序

我知道Scheme和其他Lisp方言包括逻辑运算符，如“and”和“or”，但由于我目前正在学习Scheme，所以我正在尝试编写自己的逻辑运算符。到目前为止，我对“或”的尝试都是成功的（至少从测试结果来看是如此）。我的逻辑or运算符如下所示：

(define (logical-or a b)
   (if a true b))

我试图为“and”编写一个逻辑运算符，它也返回一个布尔值，但我一直被卡住。我尝试了任意数量的组合，但我只列出以下一个组合，它不返回布尔值：

(define (logical-and a b)
(if a b false))

---

欢迎任何提示或帮助

您的

逻辑or

也不总是返回布尔值：

> (logical-or #f 2)
2

正如@leppie所说，任何不虚假的东西（f）在Scheme中都是真实的；尝试一下内置的

或
功能：

> (or 1 2)
1
> (or #f 2)
2
> (or #t 2)
#t
> (or 1 #f)
1
> (or #f #t)
#t

因此，该计划的定义是：

(define (my-or a b)
  (if a a b))

同样，对于
和
：

> (and 1 #t)
#t
> (and 1 #f)
#f
> (and 1 2)
2
> (and #f 2)
#f
> (and #t 2)
2

所以定义是

(define (my-and a b)
  (if a b a))

如果您只想返回布尔值，那么您需要编写代码

(define (logical-or a b)
  (cond
    (a    #t)
    (b    #t)
    (else #f)))

(define (logical-and a b)
  (if a
      (if b 
          #t 
          #f)
      #f))

这适用于2个值，但由于内置的
和
和
或
运算符允许任何数量的参数（甚至为0），并且仅在必要时计算其参数，因此实际定义稍微复杂一些。
您的
逻辑or
也不总是返回布尔值：

> (logical-or #f 2)
2

正如@leppie所说，任何不虚假的东西（f）在Scheme中都是真实的；尝试一下内置的
或
功能：

> (or 1 2)
1
> (or #f 2)
2
> (or #t 2)
#t
> (or 1 #f)
1
> (or #f #t)
#t

因此，该计划的定义是：

(define (my-or a b)
  (if a a b))

同样，对于
和
：

> (and 1 #t)
#t
> (and 1 #f)
#f
> (and 1 2)
2
> (and #f 2)
#f
> (and #t 2)
2

所以定义是

(define (my-and a b)
  (if a b a))

如果您只想返回布尔值，那么您需要编写代码

(define (logical-or a b)
  (cond
    (a    #t)
    (b    #t)
    (else #f)))

(define (logical-and a b)
  (if a
      (if b 
          #t 
          #f)
      #f))

这适用于2个值，但由于内置的
和
和
或
运算符允许任何数量的参数（甚至为0），并且仅在必要时计算其参数，因此实际定义稍微复杂一些。
您的
逻辑or
也不总是返回布尔值：

> (logical-or #f 2)
2

正如@leppie所说，任何不虚假的东西（f）在Scheme中都是真实的；尝试一下内置的
或
功能：

> (or 1 2)
1
> (or #f 2)
2
> (or #t 2)
#t
> (or 1 #f)
1
> (or #f #t)
#t

因此，该计划的定义是：

(define (my-or a b)
  (if a a b))

同样，对于
和
：

> (and 1 #t)
#t
> (and 1 #f)
#f
> (and 1 2)
2
> (and #f 2)
#f
> (and #t 2)
2

所以定义是

(define (my-and a b)
  (if a b a))

如果您只想返回布尔值，那么您需要编写代码

(define (logical-or a b)
  (cond
    (a    #t)
    (b    #t)
    (else #f)))

(define (logical-and a b)
  (if a
      (if b 
          #t 
          #f)
      #f))

这适用于2个值，但由于内置的
和
和
或
运算符允许任何数量的参数（甚至为0），并且仅在必要时计算其参数，因此实际定义稍微复杂一些。
您的
逻辑or
也不总是返回布尔值：

> (logical-or #f 2)
2

正如@leppie所说，任何不虚假的东西（f）在Scheme中都是真实的；尝试一下内置的
或
功能：

> (or 1 2)
1
> (or #f 2)
2
> (or #t 2)
#t
> (or 1 #f)
1
> (or #f #t)
#t

因此，该计划的定义是：

(define (my-or a b)
  (if a a b))

同样，对于
和
：

> (and 1 #t)
#t
> (and 1 #f)
#f
> (and 1 2)
2
> (and #f 2)
#f
> (and #t 2)
2

所以定义是

(define (my-and a b)
  (if a b a))

如果您只想返回布尔值，那么您需要编写代码

(define (logical-or a b)
  (cond
    (a    #t)
    (b    #t)
    (else #f)))

(define (logical-and a b)
  (if a
      (if b 
          #t 
          #f)
      #f))

这适用于2个值，但由于内置的
和
和
或
运算符允许任何数量的参数（甚至为0），并且仅在必要时评估其参数，因此实际定义稍微复杂一些。
正如Uselpa的回答和leppie的评论所述，运算符
和
和
或
不返回
#t
，而是返回决定表单结果的非
#f
的值。因此

（和“这些”都是“真”值）；=>价值观
（或“这些”都是“真”值）；=>这些

逻辑运算符
和
和
或
短路，因此它们不是过程。想象一下这个过程：

（定义（第一个真值lst）
（和（第1对）
（或（车辆lst）
（第一个真值（cdr lstщщ）'））
（第一个真值“（））；==>#F
（第一个真值“（#f#f））；=>#F
（第一个真值“（#f#f hello））；=>你好

如果用您的版本替换
和
和
或
，过程将永远不会停止对递归的求值

我们知道我们可以用
if
重写
和
<代码>（和）
是
\t
，
（和a）
是
a
，
（和a b…
是
（如果a（和b…）\f）
。我们可以使用最简单的Scheme宏，
语法规则
：

（定义语法和逻辑
（语法规则（）
（（逻辑与）#t）
（（逻辑与a）a）
（（逻辑a和b…）
（如果a（逻辑和b…#f）））

我们也可以这样做<代码>（或）
是
#f
和
（或ab…）
是
（如果a（或b…）
：

（定义语法或逻辑
（语法规则（）
（（逻辑或）#f）
（（逻辑或AB…）；注意：零元素匹配“b…”
（如果a（逻辑或b…）））

这一个有问题，因为它使用了
a
两次。。尝试
（逻辑或（显示“hello”）
。它将计算
（显示“hello”）
，从而显示两次文本。要解决此问题，我们需要将值包装在一个
let
中：

（定义语法或逻辑
（语法规则（）
（（逻辑或）#f）
（（逻辑a或b…）
（让（（tmp a））
（如果是tmp
tmp
（逻辑或b…）；（逻辑或b…）

如果您尝试相同的方法，它将只显示一次“hello”。让我们尝试使用新宏编写我的初始过程：

（定义（第一个真值lst）
（逻辑与（对？lst）
（逻辑或（车辆lst）
（第一个真值（cdr lstщщ）'））
;; 我们测试他们：
（第一个真值“（））；==>#F
（第一个真值“（#f#f））；=>#F
（第一个真值“（#f#f hello））；=>你好
正如Uselpa的回答和leppie的评论所提到的，操作符
和
和
或
不会返回
\t
，而是返回决定表单结果的不是
\f
的值。因此

（和“这些”都是“真”值）；=>瓦尔