标签: let

我有一个bash脚本的问题.我必须使用运算符*来进行乘法运算.相反,脚本会让我厌倦扩展,并使用as运算符作为脚本本身的名称.我尝试使用单引号但它不起作用:(这是代码

#!/bin/bash -x

# Bash script that calculates an arithmetic expression
# NO PRECEDENCE FOR OPERATORS
# Operators: + - * 

if [ "$#" -lt "3" ]
then 
    echo "Usage: ./calcola.scr <num> <op> <num> ..."
    exit 1
fi

result=0
op=+
j=0

for i in "$@"
do
    if [ "$j" -eq "0" ]
    then
        # first try
        #result=$(( $result $op $i )) 

        # second try
        let "result$op=$i"

        j=1
    else
        op=$i
        j=0
    fi
done

echo "Result is $result"

exit 0

我创建了一个宏,它创建一个dispatcher带有3个关联函数的命名get-dispatcher,set-dispatcher并call-dispatcher与调度程序一起工作(它们获得一个调度函数,添加一个或调用一个).一切正常!但是,现在我想自动创建相关的函数名称,因此我将宏的所有这些内部放入let定义该简单构造函数的内容中.请注意,在下面的代码中,只有get-函数的名称是使用该自动化构造的.在set-和call-那些名创建仍然有人工气味.

(defmacro create-dispatcher [name]
  ;creates a set of dispatching functions tagged

  `(do
    ;define dispatcher
    (def ~(symbol name) ~(atom {}))

    (let
      [name-w-prefix (fn [x] (~(symbol (str x "-" name))))]
        ; -- define getter
        (defn (name-w-prefix "get")
          "get-dispatcher [tag]: get a dispatcher fn by tag"
          (~'[] (println "no tag is provided for '" ~(str name) "' dispatcher"))
          (~'[tag]
            (do
              (println "dispatcher '" ~(str name) "' called …

如何let*在Chez Scheme/Racket中定义？特别是,为什么第一个例子评估为6 ......

(let* ((let +) (a (let 2 4)))
    a)

......当我从认识运动3.1.3的是,let*可扩展到嵌套let(甚至嵌套let*)语句,但扩大正如人们所预料的解释做会导致错误上面的例子？

(let ((let +))
    (let (a (let 2 4))
        a))

实施是否与练习不同？我希望第一个例子由于新的定义而导致错误let.

我正在玩Swift.为什么可以let在for循环中声明类型？据我所知,let意味着不变,所以我很困惑.

    func returnPossibleTips() -> [Int : Double] {
        let possibleTipsInferred = [0.15, 0.18, 0.20]
        //let possibleTipsExplicit:[Double] = [0.15, 0.18, 0.20]

        var retval = Dictionary<Int, Double>()
        for possibleTip in possibleTipsInferred {
            let inPct = Int(possibleTip * 100)
            retval[inPct] = calcTipWithTipPct(possibleTip)
        }

    return retval

    }

在下面的Haskell代码中,我得到一个错误"输入中的解析错误".从我读过的,我用过的缩进应该没问题.事实上,我在代码的其他地方使用'let'和'in'进行了类似的缩进('let'与'in'对齐).我打破了什么规则会导致这个'in'出现问题？如果我在'in'前面添加一个空格(使其比'let'更加一个空格),它编译得很好.

runTests :: IO ()
runTests = do
             let results = fmap testLispExpr testLispText
                 resultStrings = fmap show results
                 putSeq (x:xs) = do putStrLn x
                                    putSeq xs
                 putSeq [] = return ()
             in putSeq resultStrings

所有帮助表示赞赏.提前致谢.

大家好，我想弄清楚为什么下面的 swift 代码允许我为班级中的 wee 字符串分配一个新值。我认为 let 是不可变的，但它在这里有效。有人可以解释一下。谢谢。

import Foundation


class MyClass {
    let wee:String

    init?(inInt:Int) {
        let j:String = "what"
        //j = "I shouldn't be able to do this wiht let" // error rightly so
        //println(j)
        self.wee = "wow"
        if inInt != 2 {
            return nil
        }
        self.wee = "hey"
        self.wee = "blas" // I shouldn't be able to do this
    }


}

if let myClass:MyClass = MyClass(inInt: 2) {
    myClass.wee // prints blas
}

我在Haskell下面的代码片段中实现了一个快速排序算法.

quicksort :: (Ord a) => [a] -> [a]
quicksort [] = []
quicksort (x:xs) =
let smaller = quicksort [a | a <- xs, a <= x]
    bigger  = quicksort [a | a <- xs, a > x]
in smaller ++ [x] ++ bigger

但它不会被GHCI编译,它告诉第5行有语法错误.但是我已经检查了"let"关键字的Haskell语法,看起来还可以.有没有人可以帮我解决这个问题？非常感谢.

我想了解let绑定在Haskell中是如何工作的(或者如果Haskell实现不同,可能是lambda演算？)

我从阅读中理解为你写了一个Haskell,它对单个let绑定有效.

let x = y in e == (\x -> e) y

这对我来说很有意义,因为它与lambda演算中绑定的工作方式一致.我很困惑的地方是使用多个let绑定,其中一个绑定可以引用上面的绑定.我将提供一个简单的例子.

原始代码:

let times x y = x * y
    square x = times x x
in square 5

我对实施的猜测:

(\square times -> square 5) (\x -> times x x) (\x -> x * x)

这似乎不起作用,因为times当lambda调用square时没有定义.但是,这可以通过此实现解决:

(\square -> square 5) ((\times x -> times x x) (\x -> x * x))

这是实现此绑定的正确方法,至少在lambda演算中是这样吗？

所以我有一个克隆 let-behavior 的代码。但我不明白它是如何以及为什么起作用的。有人可以解释一下吗？

(function() {
  var a = 2;
})()

setfwhen 与 结合的行为let让我感到困惑。在这里，setf不会更改列表中的第二个值。

(defun to-temp-field (lst)
  (let ((old-value (nth 2 lst))
        (new-value 'hello))
    (progn
      (setf old-value new-value)
      lst)))

但如果我不这样做let，它会改变：

(defun to-temp-field (lst)
  (let ((new-value 'hello))
    (progn
      (setf (nth 2 lst) new-value)
      lst)))

是什么导致了这种行为？