标签: imperative

我正在阅读Tomas Petricek和Jon Skeet的'Functional Programming',我理解声明和命令式编程之间的区别.

我想知道的是原始运算符和函数是如何实现的,是由命令式运算符和函数构造的声明性语言.

干杯

AWC

我正在尝试在Haskell中编写一个程序来计算具有整数变量,一维(整数)数组和函数的命令式语言程序的指称语义.我开始的功能是这样的类型:

    progsem :: Prog -> State -> State

国家如下:

    type State (Name -> Int, Name -> Int -> Int)

第一部分是整数变量的值,而第二部分是特定索引处的数组变量的值.

该计划将具有以下品质:

• progsem将在程序执行后返回结果状态

• 函数有两个参数列表,一个用于整数变量,另一个用于数组变量.

• 函数是按值调用的结果

以下是命令式语言的抽象语法:

     -- names (variables) are just strings.
     type Name = String

     -- a program is a series (list) of function definitions, followed by a
     -- series of statements.
     type Prog = ([FunDefn],[Stmt])

     -- a statement is either...
     data Stmt =
         Assign Name Exp              -- ...assignment (<name> := <exp>;)
       | If BExp [Stmt] [Stmt]        -- ...if-then-else (if …

我在lisp语言系列中接受了一些培训,现在我正在为自己的好处学习一些Haskell.在lisp中,功能样式是可以的,但有一些情况下必须使用命令式样式才能获得不错的性能,例如

• 附加

  追加是缓慢的,因为它必须复制它的第一个参数(有时x100和成功摆脱它的版本一样慢).解决方法是将第一个列表的最后一个指针移动到第二个列表的开头,而不是附加.当然这是一种破坏性的操作.

• 分类

  quicksort的功能版本创建了许多中间列表,这些列表以某种方式违背了算法的目的,即尽可能快.AFAIR,在常见的lisp中,sort是唯一没有功能版本的破坏性功能.

• 长度

  这在lisp中是一项代价高昂的操作,因为必须在整个列表中查找其长度.这不一定是这样,afaik clojure以对数时间计算列表的长度.解决方案通常是在命令性循环中动态计算长度.

我的问题是,我们如何处理haskell中的这些问题？

你好，我正在阅读以下文章Quarkus 反应式架构

文章开头说

\n

夸库斯是反应性的。它\xe2\x80\x99s 甚至比这更重要：Quarkus 统一了反应式和命令式编程。您甚至不必选择：您可以实现反应式组件和命令式组件，然后将它们组合在同一个应用程序中。

\n

就在文章的中间下方提到

\n

借助代码中的提示（例如 @Blocking 和 @NonBlocking 注释），Quarkus 扩展可以决定应用程序逻辑何时阻塞或非阻塞。

\n

我的问题是我写反应式还是命令式重要吗？例如

反应式方法

    @GET\n    public Uni<List<Fruit>> get() {\n        return sf.withTransaction((s,t) -> s\n                .createNamedQuery("Fruits.findAll", Fruit.class)\n                .getResultList()\n        );\n    }\n

命令式方法

    @GET\n    @NonBlocking\n    public List<Fruit> get() {\n        return entityManager.createNamedQuery("Fruits.findAll", Fruit.class)\n                .getResultList();\n    }\n

这两个代码片段运行时是否具有相同的反应性优势？

我正在尝试用 Haskell 编写一个程序来键入用命令式编程语言编写的检查程序。

这是抽象语法：

    type Name = String

-- 程序是一系列（列表）变量声明和一系列（列表）语句。

    type Prog = ([TypeEnv],[Stmt])

-- 变量声明是一个类型和一个变量名

    type TypeEnv = (Type,Name)

-- 类型是“int”或“bool”，或“int[]..[]”或“bool[]..[]”

   data Type = BaseType BT | ArrayType BT Int deriving Show
   data BT = TyInt | TyBool deriving Show

——声明要么是...

   data Stmt =
   Assign Name Exp                -- ...assignment (<name> := <exp>;)
   | If Exp [Stmt] [Stmt]           -- ...if-then-else (if <bexp> { <stmt>* } else { <stmt>* })
   | While Exp [Stmt]               -- ...a while-loop (while <bexp> { <stmt>*> …

您是否可以提供当前应用程序的示例,这些应用程序是程序性的并且保持高度的完整性和效率？是否有任何书籍,教程或链接提供了如何成功构建和维护命令系统的示例？如果你在这个领域给出指导,你会给出如何构建它的提示？我问,因为OOP经常被呈现为程序编程的自然进展,但我很难相信总是如此.

当我看到众多网站时.有些人可以互换地使用面向对象的编程和命令式编程,而有些人则说它们是不同的.

我想知道面向对象和命令式之间的区别以及这些范式的区别.或者,如果他们没有任何区别.

Note: this is an exercise, and I'm trying to understand how things work.

I am trying to make it possible to do something like this in Haskell:

f :: Integer -> Integer
f n = def $ do
  i      <- var n
  while i (>0) $ do
    i      -= lit 1
  return i
-- for now, my program returns n 

Below is my program. At this point, I cannot understand why it doesn't work, but for some reason, the variables …

我有一个功能女巫是以命令式的方式编写的,无法理解如何将其转换为更强大的功能方法.

该函数接受一系列字符串并返回一个seq的元组,其中每个元组由输入中的2,7,12,...和5,10,15,...项组成.

例:

输入= {"Lorem","ipsum","dolor","set","amet","consectetuer","adipiscing","elit","Aenean","commodo","ligula","eget" ,"dolor","Aenean","massa"}

Ouput = {("ipsum","amet"),("adipiscing","commodo"),("eget","massa")}

let convert (input : seq<string>) : seq<(string * string)> =
    let enum = input.GetEnumerator()
    let index = ref 0
    let first = ref ""
    let second = ref ""

    seq {
        while enum.MoveNext() do
            let modIndex = !index % 5
            index := !index + 1

            if (modIndex % 2 = 0 && !first = "") then first := enum.Current
            if (modIndex % 5 = 0 && !second = "") then second …