如何在Scala数值泛型函数中设置默认类型？
在Scala中，可以使用上下文界定（context bounds）和默认参数来设置数值泛型函数的默认类型。
首先，定义一个数值泛型函数，使用上下文界定来限定类型为Numeric：
def sum[T: Numeric](a: T, b: T): T = {
val numeric = implicitly[Numeric[T]]
numeric.plus(a, b)
}接下来，为函数参数提供默认值，以设置默认类型：
def sum[T: Numeric](a: T = 0, b: T = 0): T = {
val numeric = implicitly[Numeric[T]]
numeric.plus(a, b)
}在上述示例中，函数sum接受两个类型为T的参数，并使用上下文界定来限定T为Numeric类型。通过为参数提供默认值，可以设置默认类型为0。
使用示例：
val result = sum(2, 3) // 使用默认类型为Int的参数
println(result) // 输出：5
val result2 = sum[Double](2.5, 3.5) // 显式指定类型为Double的参数
println(result2) // 输出：6.0在这个例子中，我们展示了如何在Scala数值泛型函数中设置默认类型。这种方法可以适用于各种数值类型，如Int、Double、Float等。对于更复杂的类型，可以根据需要进行相应的调整。
腾讯云相关产品和产品介绍链接地址：
- 腾讯云函数计算（SCF）：https://cloud.tencent.com/product/scf
- 腾讯云云服务器（CVM）：https://cloud.tencent.com/product/cvm
- 腾讯云数据库（TencentDB）：https://cloud.tencent.com/product/cdb
- 腾讯云对象存储（COS）：https://cloud.tencent.com/product/cos
- 腾讯云人工智能（AI）：https://cloud.tencent.com/product/ai
- 腾讯云物联网（IoT）：https://cloud.tencent.com/product/iotexplorer
- 腾讯云移动开发（移动推送、移动分析等）：https://cloud.tencent.com/product/mobile
- 腾讯云区块链（BCS）：https://cloud.tencent.com/product/bcs
- 腾讯云元宇宙（Tencent XR）：https://cloud.tencent.com/product/xr
相关·内容
object Demo {
def main(args: Array[String]) {
println( apply( layout, 10) )
}
def apply(f: Int => String, v: Int) = f(v)
def layout[A](x: A) = "[" + x.toString() + "]"
}
我是Scala的新手，对上面的代码有点困惑。
据我所知，apply接受另一个函数和一个整数作为输入。并将整数v作为其输入参数传递给函数f。layout[A]在
浏览 1提问于2016-06-27得票数 1
我试图弄清楚如何在类中获得泛型函数的返回类型。
例如,
declare class Test {
open<T, R>(t1: T, t2: R): T | R;
}
type TestType<T, R> = (Test['open'])<T, R>;
type TestTypeReturn = ReturnType<TestType<number, number>>;
然而，我在...])<T, R>的第4行(非空白行)上出现了错误，表示预期会出现分号。我不确定我想做的事是否可能。有人知道吗
浏览 2提问于2019-12-05得票数 1
回答已采纳
1回答
我正在学习Scala，并有以下玩具代码：
object M {
def isSorted[X](xs: Array[X], compare: (X, X) => Boolean): Boolean =
xs.dropRight(1).zip(xs.drop(1)).forall(Function.tupled(compare))
def curry[A,B,C](f: (A, B) => C) : A => (B => C) =
(a) => (b) => f(a, b)
}
我的目标是把它叫做：
M.curry(M.isSorte
浏览 2提问于2015-02-08得票数 2
回答已采纳
4回答
大多数人可能都知道在scala中有两种方法可以定义函数，有'def‘方法和lambda方法……
让'def‘类成为泛型是相当简单的
def someFunc[T](a: T) { // insert body here
我在这里遇到的问题是如何使下面的泛型：
val someFunc = (a: Int) => // insert body here
当然，现在a是一个整数，但是我需要做什么才能使它成为泛型呢？
val someFunc[T] = (a: T) =>不工作，val someFunc = [T](a: T) =>也不能工作
有没有可能让它们成为通
浏览 0提问于2013-06-29得票数 6
回答已采纳
这是的后续问题。
我希望能够传递Flink的DataSet，并对其执行一些操作，但是数据集的参数是通用的。
我现在遇到的问题是：
import org.apache.flink.api.scala.ExecutionEnvironment
import org.apache.flink.api.scala._
import scala.reflect.ClassTag
object TestFlink {
def main(args: Array[String]) {
val env = ExecutionEnvironment.getExecutionEnvironment
浏览 2提问于2015-04-09得票数 3
回答已采纳
2回答
我有一个未实现方法的特性(该特性来自第三方库，因此我无法更改它)
scala> trait A {
| def B[T](b:T):T
| }
defined trait A
我正在尝试扩展它并在其中实现B方法(尝试了三种方法)，但是我得到了以下错误。我的主要要求是，我希望将B为T实现为Int (即B[Int]并返回b*2)。
scala> class C extends A {
| def B(b:Int):Int = b*2
| }
<console>:12: error: class C needs to be abstr
浏览 1提问于2018-04-25得票数 1
回答已采纳
考虑下面的代码，我创建了一个类，它的构造函数接收带有泛型类型的参数，用于定义第二个参数所接收的参数的类型，在回调函数的参数下面是MouseEvent，因为第一个参数的值：
class MyClass<T extends keyof HTMLElementEventMap>{
constructor(tagName: T, lister: (ev: HTMLElementEventMap[T]) => any) { }
}
new MyClass("click", ev => { })
// ^^ (param
浏览 4提问于2021-02-01得票数 0
回答已采纳
下面是一个小代码示例(附带注意:我正在运行类型记录v3.8.3)：
interface IOptions<T> {
arg: T;
}
interface IExtraOptions extends IOptions<number> {
arg2: string;
}
type Func = <T, OptionsT extends IOptions<T>>(options: OptionsT) => T;
const f: Func = (options: IExtraOptions): number => {
r
浏览 5提问于2020-06-22得票数 1
回答已采纳
假设我创建了一个简单的函数来使输入加倍，
> let f1: (x: number) => number = x => x * 2;
> .type f1
let f1: (x: number) => number
如果我想取第一个值并将其加倍，我可以
let f2 = R.pipe( R.take(1), f1 );
let f2 = R.pipe( R.head, f1 );
这两种工作都是在f2([5,4,3])之外的TypeScript之外进行的。然而，有了TypeScript，
> let f2 = R.pipe( R.take(1), f1 );
浏览 1提问于2019-01-17得票数 0
2回答
我用Swift语言编写了协议和他的实现：
protocol P {
}
struct A: P {
}
协议用作某些函数的泛型类型：
func foo<T: P>(param: T) {
}
func foo() {
foo(param: A())
}
直到现在，一切都正常运转。但是，我想将A()设置为给定函数的默认参数：
func foo<T: P>(param: T = A()) {
}
不幸的是，有以下错误：
类型'A‘的默认参数值不能转换为'T’类型。
或
func foo<T: P>(param: T = A()
浏览 3提问于2016-07-12得票数 8
回答已采纳
我正在尝试定义以下函数(在Seq模块名称中共享空间)。
module Seq =
let scale value sequence =
sequence
|> Seq.map (fun v -> v * value)
但是，类型推断是强制元素和值为int类型的。我希望此方法适用于整数(8位、16位等)、浮点数(单精度和双精度)等。
为什么类型推断跳转到int，以及如何保持此函数更通用？
浏览 0提问于2015-01-20得票数 0
我正在使用Scala编写用于Hive的通用UDF。我的第一个测试是将一个函数写入和数组(复杂的数据类型)。
我的代码存根看起来如下(因为这是一个存根，请忽略asInstanceOf：d的用法)：
...
class SumElements extends GenericUDF {
protected val expectedCategories: Array[Category] = Array(ObjectInspector.Category.LIST)
protected var listInspector: ListObjectInspector = _
@throws(
浏览 1提问于2016-10-22得票数 3
回答已采纳
我正在读"Practical Common Lisp“，我想知道Common Lisp是否像Ruby一样支持Duck类型？
在Ruby中，可以在对象上调用方法，而不管是什么类，只要它实现了具有调用者假定的名称和参数列表的方法。
克洛斯呢？是否可以在不考虑对象的类的情况下调用对象上的方法，只需假设一个泛型函数就可以处理它。也许不需要鸭子类型，因为CLOS不遵循消息传递哲学，方法也不绑定到类。
浏览 0提问于2012-02-18得票数 4
回答已采纳
1回答
我创建了一个泛型函数类型，其中包含一个完全依赖于输入参数类型的返回参数，并且泛型参数有一个extends子句。下面是一个虚拟版本：
type Foo = {}
type MyFunc <T extends Foo> = (a: T, b: T) => T[];
const bar: MyFunc<number> = (a: number, b: number) => [a,b];
const baz: MyFunc<boolean> = (a: boolean, b: boolean) => [a,b];
我使用泛型参数来确保1) a和b
浏览 5提问于2022-11-29得票数 0
回答已采纳
我找到了这个解决方案，但我认为这是一个技巧：
export const getInitialValues = getFormInitialValues('formName') as (state: State) => FormValues;
在TypeScript中使用getFormInitialValues的正确解决方案是什么？
浏览 0提问于2018-08-24得票数 0
1回答
背景
我想创建以下结构(蓝色是抽象的，绿色是具体的)：
因此，我遵循并创建了以下代码：
export abstract class BaseResourceModel {
public id?: string;
}
type ConcreteClass<C> = new (...args: any[]) => C;
export interface IBaseList<T extends BaseResourceModel>
extends ConcreteClass<BaseList<T>> {
}
expor
浏览 4提问于2021-08-04得票数 2
回答已采纳
我有以下接口和函数： interface DispatchRequest<QueryStateData = any> {
(requestAction: RequestAction<any, QueryStateData>): Promise<{
data?: QueryStateData;
error?: null;
isAborted?: true;
action: any;
}>;
}
export function useDispatchRequest(): DispatchRequest; 现在，当像这样
浏览 38提问于2020-12-11得票数 0
回答已采纳
1回答
我正在试验Scala中的一种方法，该方法试图根据数字的大小对数字进行舍入，例如，如果值小于1，则至少用一个小数点对其进行舍入是有意义的；而不是保留一个整数。我想做的是：
def roundSmart[A](num: A)(implicit numeric: Numeric[A]) = num match {
case num if num < 1 => numeric.toDouble(num)
case _ => numeric.toInt(num)
}
这会引发此错误：
值<不是类型参数A的成员。
当然，参数需要接受函数签名中的一系列
浏览 1提问于2017-04-21得票数 1
1回答
因此，我试图通过Norvig &Russell的“人工智能，现代方法”来学习Scala。在这一点上，我已经很好地掌握了语言基础，但我仍然发现自己经常“与”类型系统作斗争。
长话短说，广度优先和深度优先搜索算法是相同的，除了推/弹出他们的基本集合。深度优先将增加新的可能性并使用堆栈，而广度优先将追加和使用队列。
为了保持我的算法不变，我创建了一个名为"GiveGrab“(我知道，可怕的名字)的类型，目的是拉皮条……呃..。使用这些“默认”推(Pop)和类似pop的operations.For示例丰富集合，抓取将导致队列调用.dequeue()，堆栈调用.pop()。
下面是(一个
浏览 3提问于2014-03-22得票数 2
回答已采纳
1回答
typedef car = void Function(String name, String type);
typedef String car (String name, String type);
这两种类型定义的语法有什么不同？
浏览 0提问于2021-05-05得票数 0
在调查/尝试回答mythz的问题"“时，我遇到了一些非常奇怪的行为。
这是一个bug吗？还是我疯了？
将0转换为浮点型的工作示例：(两者都会导致0.0)
var zero_float1: Float = 0
var zero_float2: Double = 0
请记住，Float是Float32 typealias，Double是Float64的typealias
extension Array {
func get_zero() -> T? {
return 0 as? T
}
}
返回0
Array<Int>().get_zero
浏览 0提问于2014-06-10得票数 1
template <typename T>
void fun1(T t) {}
template <typename T>
void fun2(T && t) {}
int i = 1;
fun1(i); // the deduced type of T is int
fun2(i); // the deduced type of T is int &
在fun1(i)和fun2(i)中推导出的T类型分别是int和int &，谁能解释编译器是如何进行推导的？
更新
这个问题不是的重复，因为：
后一项问题解释了以下的扣除规则：
tem
浏览 0提问于2018-01-17得票数 0
我想知道在数组中.toList和.toList有什么不同。我在spark-shell中做了这个测试，结果没有区别，但我不知道使用哪个更好。有什么意见吗？
scala> val l = Array(1, 2, 3).toList
l: List[Int] = List(1, 2, 3)
scala> val l = Array(1, 2, 3).to[List]
l: List[Int] = List(1, 2, 3)
浏览 14提问于2019-08-15得票数 3
回答已采纳
我不明白为什么TypeScript允许在没有指定实际泛型类型参数的情况下实例化泛型类？在下面的示例中，类Foo有一个泛型类型参数T。在行const foo = new Foo()中，可以创建一个新的foo对象，而不必指定泛型类型参数。foo的类型为Foo<unknown>，bar的类型为valueType<unknown>。
为什么有可能，而TypeScript不引发错误？这是什么用例？是否可以强迫TypeScript要求使用泛型类型参数？
type valueType<T> = {
name: string,
key: T|null,
};
浏览 2提问于2021-03-06得票数 0
回答已采纳
当我查看Scala库时，我看到这样的代码。为什么要测试A .
def test[A](block : Int => Unit) : Unit = {
block(10)
}
test { u =>
println(u)
}
我想这也是正确的。它也是这样运行的。
def test(block : Int => Unit) : Unit = {
block(10)
}
我只是好奇它背后的推理(或设计模式)是什么。谢谢。
浏览 1提问于2012-03-08得票数 2
回答已采纳
我正在为工作中的一个项目学习Circe和Scala。要解释我的问题，请从以下示例开始：
import io.circe.syntax._
object TestDrive extends App {
val labels = Seq("Banana", "Banano", "Grapefruit")
println(labels.asJson)
}
好的，这个输出：
["Banana","Banano","Grapefruit"]
这很好。
现在，我想让我的代码更通用一些。我想编写一个接受
浏览 20提问于2020-06-10得票数 1
回答已采纳
我刚接触过Rust，在一个通用函数中我有一个奇怪的行为，还有一些关于它的问题。我理解结果，但我不知道这是否正常：
trait A {
fn a() {
println!("Oh Noooo...");
}
fn b();
}
struct SA {}
impl SA {
fn a() {
println!("sa");
}
fn b() {
println!("b");
}
}
impl A for SA {
fn b() {
浏览 2提问于2022-09-26得票数 2
回答已采纳
3回答
我是scala的新手，但我有javascript的背景。
虽然我看到了在val和var (可变和不可变)之间分离的必要性，但我不明白为什么需要def语句。
如果函数是真正的一流公民，就像javascript中的那样，为什么要用def而不是val来声明它们呢？
是基于JVM相关约束的设计决策，还是存在一些我无法理解的底层逻辑？
浏览 9提问于2014-10-14得票数 6
回答已采纳
我是vb.net的新手，还有很多东西要学。这是可行的，但我相信还有更简单的方法。有人能给我指明正确的方向吗？谢谢。
Public Function GetValue(passVal As Object, valType As Type, errorVal As Object) As Object
Try
Select Case valType
Case GetType(String)
Return CType(passVal, String)
Case GetType(Date)
浏览 1提问于2016-04-15得票数 1
回答已采纳
我有以下TS代码：
export interface Id<T> {
(arg: T): T;
}
export function IdFunc<T>(arg: T): T {
return arg;
}
我想像这样使用Id和IdFunc来提供transformer的默认实现。
interface Options {
transformer: Id<number>;
}
const defaultOptions : Options = {
transformer: IdFunc<number>
^
浏览 7提问于2021-02-18得票数 0
回答已采纳
2回答
假设我们有这样的代码：
interface Vehicle {
bicycle(): string;
car(wheel: number): void;
bus(passanger: number): {
name: string;
age: number;
}[];
}
type Mapper<K extends keyof Vehicle> = (funcName: K, callback: Vehicle[K]) => void;
interface MapperB {
<K extend
浏览 4提问于2020-11-30得票数 2
回答已采纳
2回答
我正在尝试重构一个函数()，使其稍微更通用一些。以下是原始函数的定义：
def tryProcessSource(
file: File,
parseLine: (Int, String) => Option[List[String]] =
(index, unparsedLine) => Some(List(unparsedLine)),
filterLine: (Int, List[String]) => Option[Boolean] =
(index, parsedValues) => Some(true),
retainValu
浏览 1提问于2015-12-16得票数 0
1回答
我希望在进行API调用时将任何类型的类作为泛型传递到闭包中，并在从服务器获取数据后返回该类的对象，但我无法以适当的方式实现这一点。我该如何继续呢？
我的API类：
class APICall: NSObject {
public func getDataFromServer<T>(urlString:String, fileType: FileType, completionBlock: (([T]) -> Void)!) {
//API calling here and parsing data and loaded to imag
浏览 0提问于2019-04-18得票数 0
1回答
在Dart语言中，Future和Future<dynamic>类型有什么不同吗？例如，在函数的返回类型中：
Future f() { return ... }
和
Future<dynamic> f() { return ... }
浏览 0提问于2019-04-10得票数 1
回答已采纳
1回答
泛型函数找不到适用的方法
、、、
当我调用(draw win)时，我得到一个错误：“泛型函数找不到适用的方法。我刚进入CLOS，我正在使用sdl2kit简单地渲染一个窗口。”
(defclass game-window (kit.sdl2:window)
((rotation :initform 0.0)))
(defmethod render ((win game-window))
(with-slots (rotation) win
(gl:load-identity)
(gl:rotate rotation 0 0 1)
(gl:clear-color 0.0 0.0 1.0 1.0)
(gl:clear
浏览 2提问于2017-02-18得票数 0
1回答
反应特殊类型推断
、、
我想创建。
在下面的示例中，我创建了一个validateSearchParams函数，它创建了一个函数，然后可以用来包装组件。但是，类型记录(3.7.2)不能正确推断类型。
export function validateSearchParams<Props extends { location: Location }>(
test: (searchParams: URLSearchParams) => boolean,
redirectTo: string,
): (Cmp: React.ComponentType<Props>) => React
浏览 9提问于2020-03-23得票数 0
回答已采纳
1回答
我试图弄清楚泛型是如何工作的。具体来说，我没有找到一份关于编译模型的准确声明。在C++中，泛型(模板)不是单独编译的，因为它们是为每个调用站点实例化的(至少在原则上)。相反，Java泛型是单独编译的。Swift的情况是怎样的，涉及不同的泛型汇编？
浏览 0提问于2014-09-18得票数 5
回答已采纳
在阅读Keene的书时，我注意到defgeneric有一个:method选项，它似乎允许您在泛型定义本身中指定一个方法。我所见过的大多数文档都在单独的defmethod中定义了所有适用的方法，以其通常的清晰性列出了:method作为defgeneric的一个选项，但没有说明它的含义。
:method选项是默认的，或者至少是记录了您期望的最常见的用例是什么，还是它有附加的语义？作为一个样式点，如果您希望只定义一个方法，那么在defgeneric表单中(如果可以的话)或者在defmethod中单独定义它更有意义吗？或者，在这种情况下，使用常规的defun来创建泛型函数没有意义吗？
浏览 5提问于2015-04-15得票数 7
回答已采纳
1回答
为什么在TypeScript类型中别名不适用于泛型函数？例如，这里TS没有将相同类型定义为泛型。
type Identical = <T>(v: T) => T;
const identical: Identical<string> = (v) => v
我知道正确的变体是：
type Identical<T> = (v: T) => T;
但是为什么第一个示例不能工作，以及哪种类型的T
浏览 0提问于2019-11-08得票数 4
回答已采纳
2回答
有没有办法在协议中定义泛型函数，并允许一致性对象为该协议定义专门化？例如： protocol Generic {
func generic<T>(prop: T, otherProp: String)
}
class Gen: Generic {
func generic<T>(prop: T, otherProp: String) {
print("generic")
}
func generic(prop: String, otherProp: String) {
print(pr
浏览 34提问于2019-03-14得票数 2
有人能从向我解释一下这个语法吗？
export declare const useGridApiRef: <Api extends GridApiCommon = GridApiPro>() => React.MutableRefObject<Api>;
我把它读成…导出类型为<Api extends GridApiCommon = GridApiPro>的声明类型，但实际上是一个可调用的函数，该函数返回对键入的¯_(ツ)_/…的可变引用我是认真的。
我不那么关心这件事到底要做什么，而是对这个语法所声明的内容感到更加困惑。无可否认，我对TS不感兴趣，但
浏览 15提问于2022-08-02得票数 1
直角三角形的次音平方等于另一边的正方形之和。
这是毕达哥拉斯定理。根据边长"a“和"b”计算低音值的函数将返回sqrt(a *a+b* b)。
问题是，如何在Scala中定义这样一个函数，以便它可以与实现适当方法的任何类型一起使用？
就上下文而言，想象一个完整的数学定理库，你想要使用Int，Double，imagine，Double-Rational，BigInt或BigInt类型，这取决于你在做什么，以及速度、精度、准确性和范围要求。
浏览 1提问于2009-01-27得票数 25
回答已采纳
最近我一直在使用Swift，我遇到了一个奇怪的绊脚石，它的类型约束不像我所期望的那样运行(比如Scala)。
protocol Foo {
typealias T: Hashable
func somethingWithT() -> T
}
struct Bar: Foo {
typealias T = Int
func somethingWithT() -> T { return 1 }
}
func baz() -> [Foo] {
var myBars = [Foo]()
myBars.append(Bar())
浏览 4提问于2015-10-12得票数 0
回答已采纳
我有一个函数validateCell，它将一个函数func作为其输入参数之一。其内容如下：
def validateCell[String](cellKey: String, cell: Option[String], func:(String) => Boolean): Tuple2[Boolean, String] = {
cell match {
case Some(cellContents) => (func(cellContents), s"$cellContents is not valid.")
case None => (
浏览 1提问于2017-12-04得票数 2
下面是一个非常基本的设置，其中我有一个类App来处理HTTP请求(假设是这样的，HTTP服务器的代码如下所示)。
interface CallbackError {
error: string;
}
type HandlerCallback = <T>(payload?: CallbackError | T) => void;
type Handler = (callback: HandlerCallback) => void;
// omitted code here is a server that calls handleRequest on a re
浏览 3提问于2019-12-29得票数 1
回答已采纳
第一：
typedef CustomBuilder<T> = Widget Function(BuildContext context, T item);
第二：
typedef Widget CustomBuilder<T>(BuildContext context, T item);
两者似乎都有效，我想知道两者之间有什么区别吗？
浏览 0提问于2020-03-27得票数 0
回答已采纳
1回答
我不确定哪个where子句可以将泛型参数限制为从某个协议继承的协议。
protocol Edible {}
protocol PetFood: Edible {}
struct CatFood: PetFood {}
struct Rocks {}
func eat<T: Edible>(_ item: T) -> String {
return "Just ate some \(type(of: item))"
}
let food: CatFood = CatFood()
eat(food) //"Just ate some CatFo
浏览 1提问于2017-09-17得票数 2
2回答
属函数的定义
、、、
1)
下面是一个python函数summation，它可以执行立方体/平方/.的和，类似的操作。
def identity(k):
return k
def cube(k):
return pow(k, 3)
def square(k):
return pow(k,2)
def summation(n, term):
if n == 0:
return 0
else:
return term(n) + summation(n-1, term)
def sum_cubes(n):
return summati
浏览 0提问于2016-12-17得票数 0
回答已采纳
我有以下代码：
protocol Vehicle {
func start()
}
class Car: Vehicle {
func start() {
print("Start car")
}
}
class MotorCycle: Vehicle {
func start() {
print("Start MotorCycle")
}
}
let vehicles: [Vehicle] = [Car(), MotorCycle()]
func get<T: Vehicle
浏览 5提问于2020-09-11得票数 1
回答已采纳
考虑这个例子：
type State = { sth: Something };
type Selector = <T>(state: State) => T;
const selector: Selector = state => state.sth;
我希望从返回值中自动推断出selector函数的返回类型，并能够访问它的属性，但我得到了这个错误：
Type 'Something' is not assignable to Type 'T'
是否可以在不显式指定返回类型的情况下执行此操作？
浏览 13提问于2020-05-14得票数 0
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
