小编Dmy*_*tin的帖子

是否可以Option[_]在与Dataset API 一起使用的案例类中使用成员？例如.Option[Int]

我试图找到一个例子,但还没找到.这可以通过自定义编码器(映射？)来完成,但我还没有找到一个例子.

使用Frameless库可以实现这一点:https://github.com/adelbertc/frameless但是应该有一个简单的方法来完成基本的Spark库.

更新

我在用: "org.apache.spark" %% "spark-core" % "1.6.1"

尝试使用Option [Int]时出现以下错误:

无法找到存储在数据集中的类型的编码器.导入sqlContext.implicits._支持原始类型(Int,String等)和产品类型(case类).将来版本中将添加对序列化其他类型的支持

解决方案更新

由于我是原型设计,我只是在转换为数据集之前在函数内部声明了case类(在我的情况下是内部object Main {).

当我将案例类移到Main函数之外时,选项类型工作得很好.

看来 的输入Context.eval只能引用来自不同编译单元的值：

// project 1
object Z {

  val foo = "WOOF"

  def impl(c: Context)(x: c.Expr[String]) = {
    val x1 = c.Expr[String](c.untypecheck(x.tree.duplicate))
    println(s"compile-time value is: ${c.eval(x1)}")
    x
  }
  def test(x: String) = macro impl
}

// project 2
object Y {
  val foo = "GOOF"
  val boo = Z.test(Z.foo)
}


println(Y.boo)

打印出"WOOF"，但如果我将 boo 替换为val boo = Z.test(Y.foo)，则会出现以下编译错误：

Error:(32, 29) exception during macro expansion:
java.lang.ClassNotFoundException: Y$
at scala.reflect.internal.util.AbstractFileClassLoader.findClass(AbstractFileClassLoader.scala:72)
...

有什么办法可以解决这个问题吗？我知道用 quill.io 定义的查询可以引用同一范围的方法，但我无法找到他们用来允许它的技巧。

我正在学习Scala，并且尝试创建类型类来解决“每种动物都吃食物，但是食物的类型取决于动物”的问题。我有一个Eats带有上下文范围的类型类：

trait Eats[A <: Animal, B <: Edible]

object Eats {
    def apply[A, B]: Eats[A, B] = new Eats[A, B] {}
}

既Animal和Edible为抽象类。（简化的）Animal界面看起来像这样

abstract class Animal {
    type This // concrete type
    def eat[A <: Edible](food: A)(implicit e: Eats[This, B]) = // ...
}

我的目标是animal.eat(food)仅在给定类型的动物和食物存在实例（范围内的隐含值）的情况下才允许调用。为此，我创建了一个EatingBehaviour对象，该对象基本上包含所有关系的实例。例如 宣布奶牛吃草，我添加一行

implicit val cowEatsGrass = Eats[Cow, Grass]

类似于您instance Eats Cow Grass在Haskell中的编写方式。但是，现在我需要为ThisAnimal类的所有子类型指定抽象类型，以便Animal接口中的签名起作用：

class Cow extends Animal { type …

我有一个typeclass Search，Search[A]如果我们有个TypeClass1[A]或一个TypeClass2[A]实例，则有一个实例。优先考虑1实例。

编译如下：

trait TypeClass1[A]
trait TypeClass2[A]
trait Search[A]

object Search extends LPSearch {
  implicit def case1[A](implicit ev: TypeClass1[A]): Search[A] = null
}

trait LPSearch {
  implicit def case2[A](implicit ev: TypeClass2[A]): Search[A] = null
}

object Test {
  implicit val ev1: TypeClass1[Int] = null
  implicit val ev2: TypeClass2[Int] = null
  implicitly[Search[Int]]
}

就像我期望的那样，隐式搜索finds case1，finds ev1并停止搜索。

但是，如果我们更改TypeClass2为具有更多结构，则隐式搜索将停止工作：

trait TypeClass1[A]
trait TypeClass2[M[_], A]
trait Search[A]

object Search extends LPSearch …

据我了解，如果您有许多该类型的函数，f: a -> m[b]并且只要它们都返回包含在其中的值，m您应该能够通过do/bind/flatMap以下方式将它们链接起来：

f: A -> M[B]
g: B -> M[C]
h: C -> M[D]

通过>>=or flatMap(Scala)链接起来相当简单。

如何组合在 monad“盒子”中不同但里面的值是“可链接的”的函数？

f: A -> M[B]
g: B -> N[C]
h: C -> P[D]

我从未见过/读过这种情况，我知道我们可以使用liftmonad，但这会破坏 IMO 的目的。这是 monadic 结构的限制吗？我们甚至可以链接它们吗？解决这个问题的规范方法是什么？

我正在使用库https://github.com/fthomas/refined并希望转换java.util.UUID为精炼的Uuid.
如何转为java.util.UUID精炼Uuid？

更新

我有以下 http 路由：

  private val httpRoutes: HttpRoutes[F] = HttpRoutes.of[F] {
    case GET -> Root / UUIDVar(id) =>
      program.read(id)

读取函数定义如下：

  def read(id: Uuid): F[User] =
    query
      .read(id)
      .flatMap {
        case Some(user) =>
          Applicative[F].pure(user)
        case None =>
          ApplicativeError[F, UserError].raiseError[User](UserNotRegistered)
      }

编译器抱怨：

type mismatch;
[error]  found   : java.util.UUID
[error]  required: eu.timepit.refined.string.Uuid
[error]       program.read(id)
[error]         

       ^

我正在使用 scala3 进行编码，利用编程结构类型。结构类型恰好模仿了现有的案例类：它们的定义是纯粹的样板，因此很容易通过元编程来制作它们。

我了解如何制作函数实现，通常是通过类型类派生。但在这里我们正在尝试制作一个（结构）类型。

这在 scala2 中是可能的，通过类宏注释，但这些在 scala3 中已经消失了。有办法吗？如果是这样怎么办？

下面的代码是我想获得的结果：

// Library part
trait View extends scala.Selectable :
  def selectDynamic(key:String) =
    println(s"$key is being looked up")
    ???


// DSL Definition part
case class SomeDefWithInt   ( i : Int    )
case class SomeDefWithString( s : String )

// Boiler-plate code 
type ViewOf[M] = M match
  case SomeDefWithInt    => View { def i : Int    }
  case SomeDefWithString => View { def s : …

尝试掌握 Scala 3 类型系统。问题：

• 是否可以编写一个def curry(f: ???) = ...接受f任意数量并返回柯里化 fn 的通用函数？没有编译器插件，没有外部花哨的库，只是用普通 Scala 3 表达的 N 元函数？
• 我看一下这个 Haskell 示例https://riptutorial.com/haskell/example/18470/an-n-arity-curry，它的功能类似于所需的功能。

（这个问题的目的不是使用任何外部库 - 目的是学习使用 Scala 3 作为工具的函数式编程概念。有一种感觉，这可能与将 args 作为元组处理或将 fn 转换为元组 fn 相关？我觉得 fn args 和元组的概念之间存在一些对称性？）

鉴于以下类：

abstract class Foo[B] 
abstract class Baz[B, F <: Foo[B]] {
    def get(foo: F): B
    // other methods
} 

我讨厌Baz当第一个参数是多余的时我需要两个类型参数。我想写一些类似的东西：

abstract class Baz[F <: Foo[B]] {
  def get(foo: F): B
}

我是否可以在不使用多个类型参数的情况下在 Baz 中引用 B 类型（F）？这感觉应该是可能的，但我似乎无法弄清楚语法。

我正在努力加快 Scala 的速度，但对关键字“ implicit ”的使用有点困惑。

我想我理解隐式参数的概念，其中参数没有显式传入，Scala 将搜索正确类型的值（在调用范围内）。

我对“隐式 val ”的使用感到困惑。

考虑以下代码片段：

case class DemoApp() {
   implicit val foo = CustomerFoo()
}

这与传递到 DemoApp() 类构造函数的参数有关吗？

有人可以澄清一下吗？

谢谢，约翰B