小编Cac*_*tus的帖子

我使用的是maven-android-plugin版本3.3.2.当我尝试构建我的android项目时,我有以下异常:

org.apache.maven.plugin.MojoExecutionException:找不到Android SDK路径.你可以使用在POM文件插件配置部配置它<sdk><path>...</path></sdk>或<properties><android.sdk.path>...</android.sdk.path></properties>或命令行使用-Dandroid.sdk.path=...或通过设置环境变量ANDROID_HOME

但是环境变量ANDROID_HOME设置为android sdk路径.

你能帮我么？

我正在尝试在运算符和运算符上为我的自定义数据类型创建一个Semigroup和VerifiedSemigroup实例:Bool&&||

%case data Lógico = Cierto | Falso

(&&) : Lógico -> Lógico -> Lógico
(&&) Cierto Cierto = Cierto
(&&) _ _ = Falso

(||) : Lógico -> Lógico -> Lógico
(||) Falso Falso = Falso
(||) _ _ = Cierto

所以我先制作一个命名实例为Semigroup在 &&运营商:

-- Todos
instance [TodosSemigroup] Semigroup Lógico where
    (<+>) a b = a && b

但在制作VerifiedSemigroup实例时,如何告诉Idris使用TodosSemigroup实例Lógico？ …

我想创建一个Behavior t a来自一个IO a预期的语义,每次行为是sampled 时都会运行IO动作:

{- language FlexibleContexts #-}
import Reflex.Dom
import Control.Monad.Trans

onDemand :: (MonadWidget t m, MonadIO (PullM t)) => IO a -> m (Behavior t a)

我希望我可以只执行这样做measurement的pull:

onDemand measure = return $ pull (liftIO measure)

但是,在Behavior初始化之后,结果永远不会改变measure.

我可以想到的解决方法是创建一个Behavior"频繁"更改的虚拟对象,然后创建一个假依赖:

import Data.Time.Clock as Time

hold_ :: (MonadHold t m, Reflex t) => Event t a -> m (Behavior t ())
hold_ = hold () …

我想写一个程序来找到Scheme中二次方程的根.我使用LET进行某些绑定.

(define roots-with-let
  (? (a b c)
    (let ((4ac (* 4 a c))
          (2a (* 2 a))
          (discriminant (sqrt ( - (* b b) (4ac)))))
      (cons ( / ( + (- b) discriminant) 2a)
            ( / ( - (- b) discriminant) 2a)))))

4ac 因为我不想要,我定义了判别式(* 4 a c).即使我已经定义(4ac (* 4 a c)),它给了我这个错误:

expand:模块中的未绑定标识符:4ac.

我的问题是如何评估(什么顺序)？如果我想要4ac,我let应该写另一个内心let？有一个更好的方法吗？

感谢这个优秀的教程,我知道如何读取一个字符串(在这种情况下,从一个文件people.txt直接读取到一个类型的同义词:

type Person = [Int]

像这样:

people_text <- readFile "people.txt"
let people :: [Person]
    people = read people_text

我想要做的是使用数据类型(而不是类型同义词).

关于我在这里缺少什么的指示？我以为我能够直接读取字符串数据Person- 这样定义(信用到learnyouahaskell.com)

data Person = Person String String Int Float String String deriving (Show)

当我尝试显而易见的时候

 txt <- readFile "t.txt" (this works OK)

用t.txt含

"Buddy" "Finklestein" 43 184.2 "526-2928" "Chocolate"

我收到此错误:

没有实例 (Read Person)

有没有办法让默认类型实例相互定义？我想尝试这样的工作:

{-# LANGUAGE DataKinds, KindSignatures #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE UndecidableInstances #-}
data Tag = A | B | C

class Foo (a :: *) where
    type Bar a (b :: Tag)

    type Bar a A = ()
    type Bar a B = Bar a A
    type Bar a C = Bar a A

instance Foo Int where
    type Bar Int A = Bool

test :: Bar Int B
test = True

但这不起作用:

Couldn't match type `Bar Int …

我正在撰写关于依赖类型有用性的本科论文.我正在尝试构造一个容器,只能构造成一个排序列表,以便它被证明按构造排序:

import Data.So

mutual
  data SortedList : (a : Type) -> {ord : Ord a) -> Type where
    SNil : SortedList a
    SMore : (ord : Ord a) => (el: a) -> (xs : SortedList a) -> So (canPrepend el xs) -> SortedList a

  canPrepend : Ord a => a -> SortedList a -> Bool
  canPrepend el SNil = True
  canPrepend el (SMore x xs prf) = el <= x

SMore 需要运行时证明,前置元素小于或等于排序列表中的最小(第一)元素.

为了排序未排序的列表,我创建了一个函数sinsert,它接受一个排序列表并插入一个元素并返回一个排序列表:

sinsert : (ord : Ord …

所以我想要一个表示包含一组节点类型的树的类型.我也想要表示在重叠集上定义的类似树的类型.这是Typed AST问题的另一个版本.假设我的节点类型池是:

data Lit = Lit Int
data Var = Var String
data Hole = Hole Int

解析树可以包含Lits或Vars但不包含Holes.第二种称为模板的树可以包含Lits,Vars或Holes.

为了简单起见,有一种类型的递归节点被称为Add.

data Parse = A Lit | B Var
data Template = C Lit | D Var | E Hole
data Tree a = Leaf a 
            | Add (Tree a) (Tree a)

所以现在我可以声明数据,我仍然可以对它进行模式匹配,唯一的问题是语法杂乱.

aParse = Add (A Lit 3) (B Var "x")
aTemplate = Add (C Lit 4) …

我想知道是否有一般方法在ad-hoc多态函数和参数多态函数之间进行转换.换句话说,给定一个ad-hoc多态函数,如何实现其参数对应？反过来呢？

取sort,例如,它很容易写sort :: Ord a => [a] -> [a]在以下方面sortBy:

sort :: Ord a => [a] -> [a]
sort = sortBy compare

但另一种方式似乎很棘手,到目前为止,我能做的最好的事情是有点"面向对象":

import qualified Data.List as L

data OrdVal a = OV (a -> a -> Ordering) a

instance Eq (OrdVal a) where
    (OV cmp a) == (OV _ b) = a `cmp` b == EQ

instance Ord (OrdVal a) where
    (OV cmp a) `compare` (OV _ b) = a `cmp` b

sortBy :: …

我们知道,fmap是fmap :: Functor f => (a -> b) -> f a -> f b和sum是sum :: (Num a, Foldable t) => t a -> a,但下面的代码让我困惑.

> :t (fmap sum Just)
(fmap sum Just) :: Num b => b -> b
> fmap sum Just 3
3

为什么？