Haskell 扩展非类型化Lambda演算实现以覆盖简单类型化Lambda演算需要什么？

讨论如何在中实现解释器：

现在这不是问题所在。在这本书中，有一本书与之极为相似。一些（包括）实现了

---

我的问题是：扩展非类型Lambda演算实现以覆盖简单类型Lambda演算需要什么？

不清楚您在问什么，但我可以想出几个有效的答案：

• 需要更改表示以适应lambda抽象引入的变量的类型注释

• 根据您的表示方式，可以表示非类型良好的术语。如果是这样，您将需要实现一个类型检查器

• 对于求值，您不需要在LC求值器中更改任何内容，只需要忽略类型注释（这就是本文的重点）。但是，如果您编写的计算器基本上是

  evalUntyped。与编写定制的
  evalTyped
  函数相比，要证明它是总计，可能要困难得多
  

---

简单类型的lambda演算（STLC）只是在您描述的系统中添加了一个类型检查器。也就是说，您可以将此计算器视为STLC的“运行时系统”

---

侧节点：类型注释通常被添加到语言中，以简化类型检查器的工作，但它们不是必需的。

上面有一些很好的答案-我不打算减损它们

就实现类型检查器而言，在Haskell中更简单（尽管可以将其移植到Scheme中）

以下是Haskell中的一个简单类型检查器：

下面是Haskell中简单类型的Lambda演算的示例：

import Control.Applicative ((<$), (<$>))
import Control.Monad (guard)
import Safe (atMay)

data Type
    = Base
    | Arrow Type Type
    deriving (Eq, Ord, Read, Show)

data Term
    = Const
    | Var Int -- deBruijn indexing; the nearest enclosing lambda binds Var 0
    | Lam Type Term
    | App Term Term
    deriving (Eq, Ord, Read, Show)

check :: [Type] -> Term -> Maybe Type
check env Const = return Base
check env (Var v) = atMay env v
check env (Lam ty tm) = Arrow ty <$> check (ty:env) tm
check env (App tm tm') = do
    Arrow i o <- check env tm
    i' <- check env tm'
    guard (i == i')
    return o

eval :: Term -> Term
eval (App tm tm') = case eval tm of
    Lam _ body -> eval (subst 0 tm' body)
eval v = v

subst :: Int -> Term -> Term -> Term
subst n tm Const = Const
subst n tm (Var m) = case compare m n of
    LT -> Var m
    EQ -> tm
    GT -> Var (m-1)
subst n tm (Lam ty body) = Lam ty (subst (n+1) tm body)
subst n tm (App tm' tm'') = App (subst n tm tm') (subst n tm tm'')

evalMay :: Term -> Maybe Term
evalMay tm = eval tm <$ check [] tm

import Control.Applicative（（术语->可能类型
检查环境常数=返回基准
检查环境（Var v）=atMay环境v
检查环境（Lam ty tm）=箭头ty检查（ty:env）tm
检查环境（应用程序tm'）=do
箭头i o eval（底座0 tm'阀体）
评估v=v
subst:：Int->Term->Term->Term
subst n tm常数=常数
subst n tm（Var m）=案例比较m n
LT->Var m
EQ->tm
GT->Var（m-1）
subst n tm（Lam ty body）=Lam ty（subst（n+1）tm body）
subst n tm（App tm'tm'）=App（subst n tm'）（subst n tm“”）
evalMay：：术语->可能术语
evalMay tm=eval tm System F不是STLC。Simon Peyton Jones从未将System F称为简单类型lambda演算的实现。此外，GHC的中间语言具有System F缺乏的几个重要功能。其中最突出的可能是通用递归（
Rec
和
letrec
形式）。什么的例子？你是要我在Scheme中实现STLC类型系统吗？不确定。这看起来应该是一个带有两个链接的注释。
type OType = ObjType (Fix ObjType)
type OEnvironment = Map TermIdentifier OType

check :: OEnvironment -> Term OType -> OType
check env (Var i) = case lookup i env of
                      Nothing -> error $ "Unbound variable " ++ i
                      Just v -> v
check env (App f p) = let t_f = check env f
                          t_p = check env p
                       in case t_f of
                            Fun (Fix t_p') (Fix r)
                              | t_p == t_p' -> r
                              | otherwise -> error "Parameter mismatch"
                            _ -> error "Applied a non-function"
check env (Lam i ty t) = let r = check (insert i ty env) t
                          in Fun (Fix ty) (Fix r)

import Control.Applicative ((<$), (<$>))
import Control.Monad (guard)
import Safe (atMay)

data Type
    = Base
    | Arrow Type Type
    deriving (Eq, Ord, Read, Show)

data Term
    = Const
    | Var Int -- deBruijn indexing; the nearest enclosing lambda binds Var 0
    | Lam Type Term
    | App Term Term
    deriving (Eq, Ord, Read, Show)

check :: [Type] -> Term -> Maybe Type
check env Const = return Base
check env (Var v) = atMay env v
check env (Lam ty tm) = Arrow ty <$> check (ty:env) tm
check env (App tm tm') = do
    Arrow i o <- check env tm
    i' <- check env tm'
    guard (i == i')
    return o

eval :: Term -> Term
eval (App tm tm') = case eval tm of
    Lam _ body -> eval (subst 0 tm' body)
eval v = v

subst :: Int -> Term -> Term -> Term
subst n tm Const = Const
subst n tm (Var m) = case compare m n of
    LT -> Var m
    EQ -> tm
    GT -> Var (m-1)
subst n tm (Lam ty body) = Lam ty (subst (n+1) tm body)
subst n tm (App tm' tm'') = App (subst n tm tm') (subst n tm tm'')

evalMay :: Term -> Maybe Term
evalMay tm = eval tm <$ check [] tm