小编Eug*_*gen的帖子

我在做99点的问题在Haskell当我遇到了一个解决方案,以问题19,我没有完全理解.

任务是编写一个像这样工作的旋转函数

*Main> rotate ['a','b','c','d','e','f','g','h'] 3
"defghabc"

*Main> rotate ['a','b','c','d','e','f','g','h'] (-2)
"ghabcdef"

提供的解决方案是

rotate [] _ = []
rotate l 0 = l
rotate (x:xs) (n+1) = rotate (xs ++ [x]) n
rotate l n = rotate l (length l + n)

我不明白模式匹配如何达到第四行.它似乎与这个有关,(n+1)所以当n为负时,第三行不匹配,因此第四行被采用.如果是这种情况,为什么符号会以(n+1)这种方式起作用.是不是那么武断,或者是一个我不知道的惯例(数学？)？

因为我理解它的方式是在第三行递归调用rotate,参数n减1.所以我会这么认为

rotate [] _ = []
rotate l 0 = l
rotate (x:xs) n = rotate (xs ++ [x]) (n-1)
rotate l n …

假设我使用基于视图的方法来开发Android应用程序,例如以下文章中描述的内容:http://corner.squareup.com/2014/10/advocating-against-android-fragments.html

所以现在我有两个全屏视图.一个是可见的,包含一个图像网格.另一个是隐藏的,是待点击图像的详细视图.如果在单击网格中的图像时没有转换,则将隐藏网格视图并显示详细视图.现在,如果我想要一些类似于网格视图中的小图像和详细视图中的较大图像之间的共享元素过渡的内容.这样的事情可能吗？

TL; DR:有没有办法npm install在运行任何npm脚本之前自动运行如果你package.json已经被修改了？

问题场景

您拉出或签出更新的分支package.json.你跑npm run my-script.my-script取决于新添加的包package.json.my-script失败.你想知道为什么.在翻过你的桌子之前,你npm install一定要确定.my-script运行成功.你不需要一张新桌子.

我知道构建/任务运行器工具就像gradle在运行任务之前确保您的依赖项是最新的.我一直是一个(次要的)痛点,npm没有做到这一点.我偶然发现了两个我不喜欢的解决方案.

非理想的解决方案:制造

您package.json可以使用make并使用其集成的依赖关系跟踪,而不是依赖于运行命令中的npm脚本,并使用以下技巧:

# Smart install: Only executes if package.json's
# modification date is later than node_module's

node_modules: package.json
    npm install
    @rm -f node_modules/.modified
    @touch -m node_modules/.modified

install: node_modules 

资料来源:https://mattandre.ws/2016/05/make-for-hipsters/

问题是你知道必须依赖于make运行脚本并失去npm脚本的某些优点,例如方便地引用其他脚本和并行运行脚本(npm-run-all).如果他们不知道make或运行有问题,也很难与他人合作(Windows).它是node/npm生态系统之外的一个古老工具,而且这个智能安装优势太高了.

非理想解决方案:Git钩子

另一种方法是添加一个post-mergegit钩子.

问题是该解决方案是存储库的本地解决方案,无法轻松共享.npm …

在Retrofit 1.x中,我使用以下模式创建api服务类,模拟某些构建变体的错误网络连接.

// Retrofit 1
private <T> T create(Class<T> apiServiceClass) {
    T apiService = restAdapter.create(apiServiceClass);
    if (!BuildConfig.IS_PRODUCTION_BUILD) {
        endpoints = mockRestAdapter.create(apiServiceClass, apiService);
    }
    return apiService;
}

关于这一点很酷的是我使用了我的实际API端点.通过这种方式,我可以看到应用程序在片状连接上的行为,我不需要提供模拟/人工响应.

现在,在改造2的API MockRestAdapter或者说MockRetrofit完全改变了.MockRetrofit#create现在返回一个BehaviorDelegate.如果我尝试使用与以前相同的模式

// Retrofit 2
private <T> T create(Class<T> apiServiceClass) {
    T apiService = retrofit.create(apiServiceClass);
    if (!BuildConfig.IS_PRODUCTION_BUILD) {
        endpoints = mockRetrofit.create(apiServiceClass).returning(???);
    }
    return apiService;
}

我被困在了returning(???).returning期待Call<?>实施.但我似乎无法弄清楚如何实现它以使其像我的Retrofit 1示例一样工作(也许它不打算).

所以我的问题是:一般来说,如何使用Retrofit 2实现上述Retrofit 1模式以模拟实际API上的错误网络？

我的具体问题实际上并不是关于Oos接口到Haskell的一般转换.这是我能想到的最好的头衔.然而,我确信我的问题源于对使用Haskell的建模代码仍然很差的理解,以及仍然位于OO范例之内的思维模式(仍然是一个haskell初学者,你看).

我正在编写一个Mastermind(变异)模拟来测试几种Mastermind策略的适用性.事实上,我已经在Java和Lua中做到了这一点,因此这个Haskell版本只是我学习在Haskell中编程的练习.如果您对我最终想要实现的目标感兴趣,可以查看Lua/Java版本的自述文件.

但现在我的具体问题(简而言之,以OO术语):我想提供一个策略接口,以便我可以互换地将一个遵循该接口的策略放入模拟递归(循环)中,并在完成后接收一些数据关于战略的表现.另外,我想让策略保持任意状态,我不想关心每个策略保持什么样的状态.但正是这个决定 - 实际上是必不可少的 - 使一切变得复杂.另一个具体导致下面描述的问题的要求是,策略名称可以作为命令行参数提供,然后模拟以该特定策略运行.

起初我认为是适合这些要求的类型类,但在没有想出如何以这种方式对代码建模的真实想法之后我放弃了这个想法.然后我决定使用ADT,从那时起就使用它并且代码相对较远 - 直到现在.

所以,表面上的问题是如何解决我在下面提供的问题.更深层次的问题是如何在Haskell中更好地建模我对具有任意状态的接口的需求.

以下是我的代码中的简化和改编摘录:

-- reduced & simplified example
import Control.Monad.State

type Code = [Int]

data Answer = Answer { 
    blacks :: Int, 
    whites :: Int 
    } deriving (Eq, Show)

-- As you can see I decided for a type variable a that
-- represents the arbitrary state a strategy might carry
-- around. I wonder if this is the right way to do it.
-- …

我在一个模块中有一堆类.让我们说:

'''players.py'''

class Player1:
    def __init__(self, name='Homer'):
        self.name = name

class Player2:
    def __init__(self, name='Barney'):
        self.name = name

class Player3:
    def __init__(self, name='Moe'):
        self.name = name
...

现在,在另一个模块中,我想动态加载所有类players.py并实例化它们.我使用python inspect模块.

'''main.py'''
import inspect
import players

ai_players = inspect.getmembers(players, inspect.isclass)
# ai_players is now a list like: [('Player1',<class instance>),(...]
ai_players = [x[1] for x in ai_players]
# ai_players is now a list like: [<class instance>, <class...]

# now let's try to create a list of initialized objects
ai_players = …

让我们假设以下情况.应用程序的主要变体中有一个全局模块AppModule,一个作用域模块ScopedModule,一个类Main和一个类.此外,还有一个带有模块,模块和类的调试变体.只有调试变体可能知道. FooDebugAppModuleDebugScopedModuleBarBar

该主变体包含以下相关的代码片段.

@Module AppModule { /*..*/ }

@Module(injects=Main.class, addsTo=AppModule.class)
ScopedModule { @Provides Foo provideFoo() { return new Foo(); } }

class Main { scopedGraph = graph.plus(new ScopedModule(this)); }
class Foo { /*..*/ }

// In the entry point of the application
ObjectGraph.create(new AppModule());

在调试的变体包含以下相关的代码片段.

@Module(addsTo=AppModule.class, overrides=true) DebugAppModule { /*..*/ }

@Module(injects=Main.class, addsTo=DebugAppModule.class, overrides=true)
DebugScopedModule { @Provides Foo provideFoo() { …

正如标题所示,我想在我的build.gradleiff中应用插件,项目文件夹中存在某个属性文件.以下尝试

buildscript {
    File c = file('crashlytics.properties')
    ext {
        crashlytics = c.exists();
    }
}

if (crashlytics) {
    apply plugin: 'io.fabric'
}
//...

导致以下错误消息

No such property: verboseGradlePlugin for class: java.lang.Boolean

有没有办法实现我想要的？

假设我想要一个AtomicText类似于默认Link印迹的印迹,但它是不可变的,只能作为一个整体去除.进一步来说:

• 光标可以在字符之间AtomicText.
• 可以选择部分AtomicText.
• 删除至少一个字符AtomicText导致删除整体AtomicText.
• AtomicText创建后无法添加字符.既不通过键盘事件也不通过复制和粘贴.

我的想法是AtomicText从Embed印迹中扩展.在这种情况下,AtomicText当光标位于其最后一个字符并且按下退格键时,将删除整个印迹.但其他操作无法按预期工作.我假设我需要覆盖一些Blot方法来实现正确的行为,但我在这里有点不知所措.

另一个想法是监听text-change事件,确定光标是否在AtomicText污点内并相应地采取行动.例如,当按退格键时,找到当前AtomicText印迹的开始和结束位置,并删除这些索引之间的所有字符.这似乎是一种脆弱的方法.

任何指针将不胜感激.

类似的问题/要求如下:

• 如何在quilljs中制作不可选择的嵌入自定义格式
• 如何在Quill编辑器中向内容添加不可编辑的标记
• Quill Editor:基于标签/类的限制编辑

我正在使用准模块方法"从表中 - 在内部使用本地",如本页所述.

local M = {}

-- private
local x = 1
local function baz() print 'test' end

local function foo() print("foo", x) end
M.foo = foo

local function bar()
  foo()
  baz()
  print "bar"
end
M.bar = bar

return M

但是,在定义函数后,我不会向模块表中添加函数等.相反,我在文件的底部做.

local x = 1
local function baz() print 'test' end

local function foo() print("foo", x) end

local function bar()
  foo()
  baz()
  print "bar"
end

local M = {
  bar = bar,
  foo = foo,
}
return …