有没有办法在scala对象中隐式添加方法？
更新:例如,Unfiltered scala库具有singleton对象Body,该对象包含方法Body.string(req: HttpRequest)和Body.bytes(req: HttpRequest)来自http请求的读取主体.所以,我想在我的域对象中读取body,比如Body.cars(req:HttpRequest).
我有以下课程:
class Example(implicit doSomething1: (Double, Double) => Double, implicit doSomething2: (Double, Double) => Double)
{
//..
}
如您所见,构造函数有两个具有相同声明的隐式参数(函数).但我想"注入"两个不同的定义.这可能是隐含的吗？或者只能以已知的显式方式进行？
谢谢
我从不喜欢隐式运算符(更喜欢扩展方法),因为在代码中发生转换/转换时很难直观地看到它们.
想象一下,如果你有如下例子:
public static implicit operator Deal(string dealAsXml)
{
//convert the xml into Deal object
}
上面的隐式运算符可以帮助您将Xml格式的交易转换/转换为Deal Object.
通常当您右键单击某个方法时,可以在其上使用"查找用法"(或Alt + F7),这非常有用,隐式运算符是否有类似内容？
我认为这是在可能的情况下使用Extensions方法的另一个原因.
我正在尝试一组自定义容器函数,并从Scala的集合库中获取有关CanBuildFrom[-From, -Elem, -To]隐式参数的灵感.
在Scala的集合中,CanBuildFrom支持返回类型函数的参数化map.在内部,CanBuildFrom参数像工厂一样使用:map在它的输入元素上应用它的第一个顺序函数,将每个应用程序的结果提供给CanBuildFrom参数,最后调用CanBuildFrom的result方法来构建调用的最终结果map.
在我的理解中,-From类型参数CanBuildFrom[-From, -Elem, -To]仅用于apply(from: From): Builder[Elem, To]创建Builder具有一些元素的预初始化.在我的自定义容器函数中,我没有那个用例,所以我创建了自己的CanBuildFrom变体Factory[-Elem, +Target].
现在我可以有一个特质 Mappable
trait Factory[-Elem, +Target] {
def apply(elems: Traversable[Elem]): Target
def apply(elem: Elem): Target = apply(Traversable(elem))
}
trait Mappable[A, Repr] {
def traversable: Traversable[A]
def map[B, That](f: A => B)(implicit factory: Factory[B, That]): That =
factory(traversable.map(f))
}
和实施 Container
object Container …我很新见,但是当我使用sympy 绘制隐式函数(实际上是Cassini椭圆的公式)时,我已经得到了很好的输出:
from sympy import plot_implicit, symbols, Eq, solve
x, y = symbols('x y')
k=2.7
a=3
eq = Eq((x**2 + y**2)**2-2*a**2*(x**2-y**2), k**4-a**4)
plot_implicit(eq)
现在实际上可以以某种方式获得对应于图的x和y值吗？或者在没有绘图的情况下求解隐式方程？
谢谢!:-)
我只是想要更深入地理解Python中的JSON和Dict.
我有一个来自这样的服务器的JSON响应:
`{"city":"Mississauga","country":"Canada","countryCode":"CA"}`
我想把它作为一本字典来处理.为此,我使用.json()函数.为什么我可以通过使用获取数据res.json()['city'],但不能用它来做req.json().city？
在Scala 2.12中导入global执行上下文然后在作用域中定义了另一个隐式执行上下文导致模糊隐式,而在2.11中它可以正常工作.
import scala.concurrent._
import scala.concurrent.ExecutionContext.Implicits.global
class A(implicit ec: ExecutionContext) {
x = implicitly[ExecutionContext]
}
编译器给出错误:
error: ambiguous implicit values:
both lazy value global in object Implicits of type => scala.concurrent.ExecutionContext
and value ec in class A of type scala.concurrent.ExecutionContext
match expected type scala.concurrent.ExecutionContext
val x = implicitly[ExecutionContext]
^
这是什么原因以及如何在代码中解决它？
我正在尝试编写通用的加权平均函数.我想放宽对值和重量相同类型的要求.即,我想支持说:(value:Float,weight:Int)和(value:Int,weight:Float)参数的序列而不仅仅是:(value:Int,weight:Int)
为此,我首先需要实现一个带有两个通用数值并返回其产品的函数.
def times[A: Numeric, B: Numeric](x: B, y: A): (A, B) : ??? = {...}
编写签名并考虑返回类型,让我意识到我需要为Numerics定义某种层次结构来确定返回类型.即x:Float*y:Int=z:Float,x:Float*y:Double=z:Double.
现在,数字类定义操作plus,times等只为同一类型的参数.我想我需要实现一个类型:
class NumericConverter[Numeirc[A],Numeric[B]]{
type BiggerType=???
}
这样我就可以把我的时间函数写成:
def times[A: Numeric, B: Numeric](x: B, y: A): (A, B) :
NumericConverter[Numeirc[A],Numeric[B]].BiggerType= {...}
并将"较小的类型"转换为"较大的类型"并将其转换为times().
我是在正确的轨道上吗？我将如何"实施" BiggerType？
显然我做不了类似的事情:
type myType = if(...) Int else Float
因为它是动态评估的,所以它不起作用.
我知道我可以使用Scalaz等来做这个,但这是一个学术练习,我想了解如何编写一个静态返回基于参数类型的类型的函数.
如果有更简单的方法,请随时告诉我.
更新:
这就是我想出来的.
abstract class NumericsConvert[A: Numeric,B: Numeric]{
def AisBiggerThanB: Boolean …我正在使用 doobie 查询一些数据，一切正常，如下所示：
case class Usuario(var documento: String, var nombre: String, var contrasena: String)
def getUsuario(doc: String) =
sql"""SELECT documento, nombre, contrasena FROM "Usuario" WHERE "documento" = $doc"""
.query[Usuario]
.option
.transact(xa)
.unsafeRunSync()
但是，如果我声明一个具有类型限制的函数，如下所示：
def getOption[T](f: Fragment): Option[T] = {
f.query[T]
.option
.transact(xa)
.unsafeRunSync()
}
我收到了这些错误：
Error:(42, 12) Cannot find or construct a Read instance for type:
T
This can happen for a few reasons, but the most common case is that a data
member somewhere within this type doesn't have …https://docs.scala-lang.org/scala3/reference/metaprogramming/compiletime-ops.html上的 Scala 3 参考文献提到了 Scala 3 mataprogramming 可能实现的一些“类似 Prolog 的编程风格”：
到目前为止的问题是，类似于 Prolog 的隐式搜索编程风格变得病毒式传播：一旦某个构造依赖于隐式搜索，它就必须被编写为逻辑程序本身。
但它们都保留了基于逻辑编程的隐式搜索程序的病毒性。
我做了一些搜索，但只知道它在某种程度上滥用了 Scala 编译时行为，并且其中的某些内容类似于 Prolog。
什么是“类似 Prolog 的编程风格”以及它是如何工作的？什么类似于Prolog？它在 Scala 3 中有效吗？