有一个伟大的教程在这里,这似乎暗示,我认为作家单子基本上是做代表的工作的特殊情况,元组对象(A,B).作者在左边积累了值(即A),并且A与它有相应的Monoid(因此它可以累积或改变状态).如果A是一个集合,那么它就会累积.
State Monad也是一个处理内部元组的对象.它们都可以是flatMap'd,map'd等等.这些操作对我来说都是一样的.他们有什么不同？(请用scala示例回复,我不熟悉Haskel).谢谢!
Java 8中的monadic编程是否更慢？下面是我的测试(使用右偏置的Either为每次计算创建新实例).命令式版本快1000倍.如何在Java8中编程monadicaly同时获得可比性能？
Main.java
public class Main {
public static void main(String args[]){
Main m = new Main();
m.work();
m.work2();
}
public void work(){
final long start = System.nanoTime();
final Either<Throwable,Integer> result =
Try(this::getInput).flatMap((s) ->
Try(this::getInput).flatMap((s2) ->
parseInt(s).flatMap((i) ->
parseInt(s2).map((i2) ->
i + i2
))));
final long end = System.nanoTime();
result.map(this::println).leftMap(this::println);
System.out.println((end-start)/1000+"us to execute");
}
public void work2(){
Object result;
final long start = System.nanoTime();
try {
final String s = getInput();
final String s2 = getInput();
final int i = …我想了解Shapeless,我遇到了这个:
// Base trait for type level natural numbers.
trait Nat {
type N <: Nat
}
// Encoding of successor.
case class Succ[P <: Nat]() extends Nat {
type N = Succ[P]
}
// Encoding of zero.
class _0 extends Nat {
type N = _0
}
_0是一个特殊而独特的案例,就像Nil一个List._0没有前任.为什么它不是一个对象/案例对象(单例)？ HList似乎这样做:
// `HList` ADT base trait.
sealed trait HList
// Non-empty `HList` element type.
final case class ::[+H, +T <: HList](head : H, …我正在使用地址做事,而成员子预设(公寓/公寓#)导致检索错过.我也担心subpremise是我唯一索引约束的一部分,因为它可以为null.
故障过滤器:
tableQuery.filter(c=> (c.longitude === r.longitude && c.latitude === r.latitude) ||
(c.streetNumber === r.streetNumber && c.route === r.route && c.subpremise === r.subpremise && c.neighborhoodId === r.neighborhoodId))
成功过滤:(通过removung subpremise)
tableQuery.filter(c=> (c.longitude === r.longitude && c.latitude === r.latitude) ||
(c.streetNumber === r.streetNumber && c.route === r.route && c.neighborhoodId === r.neighborhoodId))
如果还有其他一些我错过的因素,我已经将这些定义包括在下面了,希望它会被注意到.
case class Address(id:Option[Long],streetNumber:Short,route:String,subpremise:Option[String],neighborhoodId:Fk,latitude:Option[Double],longitude:Option[Double])
class Addresses(tag: Tag) extends Table[Address](tag, "addresses") with Logging {
def id = column[Long]("id", O.PrimaryKey, O.AutoInc)
def streetNumber = column[Short]("street_number")
def route = column[String]("route",O.NotNull)
def subpremise = …val vLInts = (1 to 10).toList.right[String]
for {
i <- ListT(vLints)
_ = println(i)
} yield i
//error: no type parameters for method apply:(underlying: M[List[A]])scalaz.ListT[M,A] in object ListT exist so that it can be applied to arguments (scalaz.\/[String,List[Int]])
这里的问题是析取\/[A, B]有2个泛型,因此不是Monad.当我做一个类型别名
type Attempt[A] = \/[String, A]
它成功了,因为我把左侧固定,我现在有Monad.如果最外面的类型是Disjunction,如何不使用类型别名,我怎样才能让我的Monad Transformer工作？
我正在使用"完全懒惰",我渴望Either<String,Option<A>>在我正在编写的程序中.这是一个使用Monad Transformer for Option的好地方(类似于Scalaz 7中存在的那个很棒).我似乎无法在Java 8中使用Generics.下面的代码是我喜欢它的样子(一开始).任何关于如何让它工作/编译的建议都是惊人的!!! 请帮我把这个Monad Transformer存在为我的Java 8代码.
import com.googlecode.totallylazy.Monad;
import com.googlecode.totallylazy.Option;
import com.googlecode.totallylazy.functions.Function1;
import static com.google.common.base.Preconditions.checkNotNull;
public class OptionT<M extends Monad,A> {
final M<Option<A>> run;
public OptionT(final M<Option<A>> run){
this.run = checkNotNull(run);
}
public <B> OptionT<M,B> map(Function1<A,B> f){
return new OptionT<M,B>(run.map(o-> o.map(f)));
}
}
编辑:我得到以下编译器失败:
OptionT.java:15: error: unexpected type
final M<A> run;
^
required: class
found: type parameter M
where M is a type-variable:
M extends Monad<Option<?>> declared in class OptionT
OptionT.java:17: error: unexpected type …java generics functional-programming monad-transformers java-8
我可以编写一个 State Monad（在 Scala/Java 中），并且当我看到其他人使用它时，我几乎可以遵循逻辑。我不完全理解它正在解决的问题。它是一个包裹 funciton 的 monad S => (S,A)。
因此，当您通过 flatMap 嵌套导致 State Monad 的函数时，它会为您提供一组对数据执行的指令/操作(S)（但尚未执行它们）。直到最后，当你给它一个S并告诉它运行时，它才起作用。
与仅编写函数来完成相同的事情相比，这样做有什么好处？
Monad 不会组合，因此以这种方式拥有这些功能似乎对设计有很大的影响。如果您提供示例代码，请使用 Java 或 Scala（因为我不明白如何阅读 Haskell 或其他严格的函数式语言）。汉克斯！
我只看过如下组合函数(或使用lambdas的人)的例子.
Function<A,B> inner = ....;
Function<B,C> outter = ....;
Function<A,C> result = outter.compose(inner);
我想使用"compose"功能编写以下函数,而不是直接调用它们.
public class J{
public static B inner(final A a){...}
public static C outter(final B b){...}
}
public class K{
public static Function<A,C> result = (J::outter).compose(J::inner);
}
这不编译.我似乎无法使用java.util.function.Function的"compose"成员.我如何为传统声明的函数执行此操作？我想避免以下情况:
public class K{
public static Function<A,C> result = (a)-> J.outter(J.inner(a));
}
可以吗？提前致谢