编辑:用户@apocalisp和@BenjaminHodgson在下面留下了很棒的答案,跳过阅读大部分问题并跳转到他们的答案.

问题的TLDR:我怎样才能从FSM表示组合爆炸的第一张图片到第二张图片,在那里您只需要在继续之前访问所有这些图片.

我想构建一个有限状态机(真的在Haskell中,但我首先尝试使用Idris来查看它是否可以指导我的Haskell),其中有一些临时状态必须在达到最终状态之前访问.如果我可以通过某种状态的谓词任意约束FSM,那就太好了.

在下图中,有一个Initial州,3个临时州A, B, C和一个Final州.如果我没有弄错,在"正常"FSM中,您将始终需要n!临时状态来表示可能路径的每个组合.

这是不可取的.

相反,使用Type Families和可能的Dependent类型,我认为应该有一种状态可以随身携带,只有当它通过某些谓词时才允许你进入最终状态.(这是否会使自动推送自动机而不是FSM？)

到目前为止,我的代码(idris),通过类比,添加成分来制作沙拉,顺序无关紧要,但它们都需要在以下内容中实现:

data SaladState = Initial | AddingIngredients | ReadyToEat

record SaladBowl where
       constructor MkSaladBowl
       lettuce, tomato, cucumber : Bool

data HasIngredient : (ingredient : SaladBowl -> Bool) -> (bowl : SaladBowl ** ingredient bowl = True) -> Type where
     Bowl : HasIngredient ingredient bowl

data HasIngredients : (ingredients : List (SaladBowl …

经过大量研究，我不确定最佳实践是什么，我的以下想法是否合适？

我想要访问一个 API，该 API 将我可以进行的调用总数限制为每分钟 50 次。

我的程序有多个独立运行的线程。

如何限制我的程序保持在阈值以下？

我的想法是创建一个队列，并每 X 秒向其中添加一件事，其中 X = thread_count/allowed_calls*60。然后需要一个单独的线程来处理这些请求。（还有一个单独的线程用于定期添加）

对于这样的事情，最佳实践是什么？有没有一种方法可以实现这一目标，而不需要为每个小功能提供完全独立的线程？

我刚刚注意到,该pipeline家族返回了一个channel看似完全独立于管道目的的操作及其相关渠道.

在下面的例子中,你可以看到>! / <!来自pipes与a> / b>独立,以及他们无关.

据我了解,pipelineS的关系是一个空操作,并返回nil在设置sideffecting transduc从灰a>到b>.

那么,我错过了什么,为什么要pipeline回来channel？

(def a> (chan))
(def b> (chan))
(def pipes (pipeline-blocking 4
                     b>
                     (map clojure.string/upper-case)
                     a>))
(go (>! pipes "hello world"))
(go (println "Pipes: " (<! pipes)))
(go (>! a> "apples are gooood"))
(go (println "B: " (<! b>)))

Haskell 作为一种网络语言已经变得很有用了（谢谢Servant！），但 JSON 对我来说仍然很痛苦，所以我一定是做错了什么（？）

我听到 JSON 被提及为一个痛点，我听到的回应围绕着“使用 PureScript”、“等待子/行输入”、“使用深奥的，如 Vinyl”、“Aeson + 只是处理爆炸式增长”样板数据类型”。

作为一个（不公平的）参考点，我真的很喜欢 Clojure 的 JSON“故事”的轻松性（当然，它是一种动态语言，并且有它的权衡，为此我仍然更喜欢 Haskell）。

这是我盯着一个小时的例子。

{
    "access_token": "xxx",
    "batch": [
        {"method":"GET", "name":"oldmsg", "relative_url": "<MESSAGE-ID>?fields=from,message,id"},
        {"method":"GET", "name":"imp", "relative_url": "{result=oldmsg:$.from.id}?fields=impersonate_token"},
        {"method":"POST", "name":"newmsg", "relative_url": "<GROUP-ID>/feed?access_token={result=imp:$.impersonate_token}", "body":"message={result=oldmsg:$.message}"},
        {"method":"POST", "name":"oldcomment", "relative_url": "{result=oldmsg:$.id}/comments", "body":"message=Post moved to https://workplace.facebook.com/{result=newmsg:$.id}"},
        {"method":"POST", "name":"newcomment", "relative_url": "{result=newmsg:$.id}/comments", "body":"message=Post moved from https://workplace.facebook.com/{result=oldmsg:$.id}"},
    ]
}

我需要将其发布到 FB 工作场所，该工作场所会将消息复制到新组，并评论两个组上的链接，相互链接。

我的第一次尝试看起来像这样：

data BatchReq = BatchReq {
  method :: Text
  , name :: Text
  , relativeUrl :: Text
  , body :: Maybe Text …

编辑：我提出了一个更具体的问题。谢谢这里的回答者，我认为后续问题可以更好地解释我在这里引入的一些困惑。

TL;DR我正在努力将约束证明放入表达式中，同时在构造函数上使用具有存在约束的 GADT。（这是一个严肃的口，抱歉！）

我将问题归结为以下几点。我有一个简单的 GADT，它表示名为 的点X和名为 的函数应用程序F。点X被限制为Objects。

data GADT ix a where\n  X :: Object ix a => a -> GADT ix a\n  F :: (a -> b) -> GADT ix a -> GADT ix b\n

Constrained指的是其对象受某物约束的容器，并且Object是某物。（编辑：我真正的问题涉及Category约束类别Cartesian中的类）

-- | I can constrain the values within containers of …

HaskellHMatrix可以让你方便地获取切片：

m ?? (All, Take 3)

但是如何设置切片，尤其是非矩形切片呢？例如，在 Python 的 Numpy 中我会这样做：

>>> x = np.arange(12).reshape(3, 4)
>>> x
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
>>> x[[0,0], [1,3]] += x[[2,2], [1,3]]     # to ix (0, 1) add (2, 1)  and  to ix (0, 3) add (2, 3)
>>> x
array([[ 0, 10,  2, 14],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

我可以自己编写这个辅助函数，但是，它确实丑陋且不完整，并且需要我添加zipWith3M_ …

TL; 博士

有没有办法在算术运算中使用聚合结果？

细节

我想取两个聚合列 ( SUM(..), COUNT(..)) 并将它们一起操作，例如：

-- doesn't work
SELECT 
    SUM(x) AS x, 
    COUNT(y) AS y, 
    (x / y) AS x_per_y -- Problem HERE
FROM
    my_tab
GROUP BY groupable_col;

这不起作用，但我发现这样做：

SELECT 
    SUM(x) AS x, 
    COUNT(y) AS y, 
    SUM(x) / COUNT(y) AS x_per_y -- notice the repeated aggregate
FROM
    my_tab
GROUP BY groupable_col;

但是如果我需要对聚合进行操作的许多列，它很快就会变得非常重复，而且我不确定如何判断 MySQL 是否可以优化，以便我不会多次计算聚合。

我已经搜索了一段时间，并询问了一些专业人士，我能想到的最佳选择是嵌套选择，~~我的数据库不支持。~~

编辑：它确实支持他们，我一直在做错事，并过早地排除了嵌套选择

此外，MySQL 文档似乎支持它，但我无法让这样的东西工作（链接最底部的示例）

https://dev.mysql.com/doc/refman/5.5/en/group-by-handling.html

作为理解之旅的一部分,我singletons试图弥合编译时安全性与将运行时值提升到相关类型安全性之间的差距.

我认为,"运行时"值的最小示例是一个采用无界列表的函数,并将其转换为大小索引的向量.以下骨架提供了长度索引向量,但我无法确定如何编写fromList.

我已经考虑过使函数采用size参数,但我怀疑它可以保持隐含.

{-# LANGUAGE GADTs                #-}
{-# LANGUAGE ScopedTypeVariables  #-}
{-# LANGUAGE TemplateHaskell      #-}
{-# LANGUAGE TypeFamilies         #-}
{-# LANGUAGE TypeInType           #-}
{-# LANGUAGE UndecidableInstances #-}

import           Data.Singletons
import           Data.Singletons.TH

$(singletons
  [d|
    data Nat = Z | S Nat deriving (Show)
  |])

data Vec a n where
  Nil :: Vec a Z
  Cons :: a -> Vec a n -> Vec a (S n)

instance Show a => Show (Vec a n) where
  show Nil …

我正在调试一些代码，并将我的问题归结为一个简单的示例：

(js/console.log (.-hey (clj->js {:hey "please work!"})))

印刷undefined

它一定与高级优化期间的重命名有关，但我不知道发生了什么，也不知道如何修复它......

如果您使用在线 CLJS REPL，例如http://clojurescript.net/，它会按预期工作（返回nil但打印please work!），但在使用高级优化下cljsbuild，它根本不起作用！

嗯，知道我哪里搞砸了吗？

编辑： 经过进一步反思，以及 clojurians 关于 slack 的一些建议，我认为，这是因为当我使用clj->js.

我发现我（认为）我需要这样做，因为我正在尝试与 D3.js 库（来自 cljsjs）进行互操作，并且当我传递它的东西时，它期待的是js对象，而不是cljs对象。是否有一种惯用的方法将 cljs 对象传递到您正在交互的 js 库？（如果这确实是我的问题？）

我想弄清楚如何最好地创建异步组件,或以组件友好的方式容纳异步代码.这是我能想到的最好的,而且......感觉不太对劲.

要点:言语,uppercase他们和reverse他们,最后是print他们.

问题1:我无法system在最后停止.我希望看到一个println人c-chan停止,但不要.

问题2:如何正确注入deps.进入producer/ consumerfns？我的意思是,他们不是组件,而且我想他们应该不会是组件,因为他们没有明智的生命周期.

问题3:我如何惯用处理async/pipeline命名的创建副作用a>b,和b>c？应该pipeline是一个组件吗？

(ns pipelines.core
  (:require [clojure.core.async :as async
             :refer [go >! <! chan pipeline-blocking close!]]
            [com.stuartsierra.component :as component]))


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; PIPELINES
(defn a>b [a> b>]
  (pipeline-blocking 4
                     b>
                     (map clojure.string/upper-case)
                     a>))
(defn b>c [b> c>]
  (pipeline-blocking 4
                     c>
                     (map (comp (partial apply str)
                                reverse))
                     b>))


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; …

第一行代码使用"离散标签"创建一些向量,第二行代码创建一个稀疏矩阵,在标签所代表的索引处有一个."eye"会创建一个单位矩阵,但即使向量"a"更长,创建稀疏矩阵的效果仍然有效!？

你能帮我理解发生了什么吗？

octave:4> a = [1 3 5 7 9 2 4 6 8 10]
a =

    1    3    5    7    9    2    4    6    8   10

octave:5> eye(10)(a,:)
ans =

Permutation Matrix

   1   0   0   0   0   0   0   0   0   0
   0   0   1   0   0   0   0   0   0   0
   0   0   0   0   1   0   0   0   0   0
   0   0   0   0   0   0   1   0   0   0
   0   0   0   0   0   0   0 …