R 2.3.0 - en to zh_CN translation catalogue (385 entries)

en: OOPS: something wrong with '.OldClassesPrototypes[[%d]]'
zh_CN: 啊呀：'.OldClassesPrototypes'里第[[%d]]行那里出错了

en: unnamed argument to initialize() for S3 class must have a class definition; %s does not
zh_CN: 给S3类别用的initialize()函数中没有名称的参数必需有类别定义；但%s没有

en: unnamed argument must extend either the S3 class or the class of the data part; not true of class %s
zh_CN: 没有名称的参数要么扩充S3类别，要么扩充数据类别；%s类别没有做到这一点

en: class %s does not have an S3 data part, and so is of type "S4"; no S3 equivalent
zh_CN: 类别%s不包含S3数据部分，因此其类型为"S4"；而不是S3同变类别

en: class %s is VIRTUAL; not meaningful to create an S4 object from this class
zh_CN: %s是虚拟类别；用这类型别来建立新的S4目标对象是没有意义的

en: object must be a valid data part for class %s; not true of type %s
zh_CN: %s类别的目标对象必需包含有效的数据部分；但%s类型不是这样的

en: cannot specify matrix() arguments when specifying '.Data'
zh_CN: 在指定'.Data'时不能同时指定matrix()参数

en: cannot specify array() arguments when specifying '.Data'
zh_CN: 在指定'.Data'时不能同时指定array()参数

en: cannot have more than one unnamed argument as environment
zh_CN: 不能有超过一个的无名参数来作为环境用

en: unnamed argument to new() must be an environment for the new object
zh_CN: 为新对象调用new()时中的无名参数必需是环境

en: methods may not be defined for primitive function %s in this version of R
zh_CN: 此版本的R没有给基元函数%s定义方法

en: S3Part() is only defined for classes set up by setOldCLass(), basic classes or subclasses of these:  not true of class %s
zh_CN: S3Part()只适用于由setOldCLass()，基本类别，或基本类别或这些类别的子类别%s类别不是这种情况

en: the 'S3Class' argument must be a superclass of %s:  not true of class %s
zh_CN: 'S3Class'参数必需是%s的母类别: %s不是这种情况

en: replacement value must extend class %s, got %s
zh_CN: 替换值必需扩充%s类别，但现在得到的是%s

en: replacement value must be of class %s, got one of class %s
zh_CN: 替换值的类别必需是%s，但现在得到的类别是%s

en: no 'replace' method was defined for 'as(x, "%s") <- value' for class %s
zh_CN: 不存在%2$s这一类别用于'as(x, "%1$s") <- value'函数的'replace'方法

en: the 'coerce' argument to 'setIs' should be a function of one argument, got an object of class %s
zh_CN: 'setIs'的'coerce'参数值必需是单参数函数，而现在它却是类别为%s的对象

en: the computation: 'as(object,"%s") <- value' is valid when object has class %s only if 'is(value, "%s")' is TRUE ('class(value)' was %s)
zh_CN: 运算出错：当object的类别是%2$s时，'as(object,"%1$s") <- value'只能在'is(value, "%3$s")'值为TRUE的时候才能用('class(value) '的值不能是%4$s)

en: there is no automatic definition for 'as(object, "%s") <- value' when object has class %s and no 'replace' argument was supplied; replacement will be an error
zh_CN: 当对象的类别为%2$s而'replace'参数不存在的话，没有自动定义的'as(object, "%1$s") <- value'这样一个函数；因此替换时将出错

en: the 'replace' argument to setIs() should be a function of 2 or 3 arguments, got an object of class %s
zh_CN: setIs()的'replace'参数必需是个二或三参数的函数，现在得到的却是类别为%s的对象

en: the member classes must be defined: not true of %s
zh_CN: 必需设定成员类别: %s没有这样的设定

en: unable to create union class:  could not set members %s
zh_CN: 无法建立併集类别: 无法设定%s成员

en: methods:::bind_activation() is defunct;
     rather provide methods for cbind2() / rbind2()
zh_CN: methods:::bind_activation() 已弃用;
     请使用 cbind2() / rbind2() 方法

en: invalid argument 'name': %s
zh_CN: 参数'name'无效: %s

en: %s dispatches internally;  methods can be defined, but the generic function is implicit, and cannot be changed.
zh_CN: %s 内部调度; 可以定义方法，但泛型函数是隐式的，不能更改。

en: if the 'def' argument is supplied, it must be a function that calls standardGeneric("%s") or is the default
zh_CN: 如果设定了`def'参数的话，它要么是調用standardGeneric("%s")的函数，要么是默认值

en: must supply a function skeleton for %s, explicitly or via an existing function
zh_CN: 必需提供函数%s的骨架，要么是明确地提供，要么通过已存在的函数来提供

en: Creating a generic function for %s from %s in %s
        (from the saved implicit definition)
zh_CN: %3$s里的从%2$s为%1$s建立新的泛型函数(从保存的隐式定义)

en: Creating a new generic function for %s in %s
zh_CN: 为%2$s里的%1$s建立新的泛型函数

en: no generic version of %s on package %s is allowed;
       a new generic will be assigned for %s
zh_CN: 程序包%2$s不允许泛型版本的%1$s；
    一个新的泛型函数将会同程序包%3$s一起被分配

en: generic function %s not found for removal
zh_CN: 没有%s这样的泛型函数，因此不能将之删除

en: a function for argument 'f' must be a generic function
zh_CN: 为参数'f'提供的函数必需是泛型函数

en: the environment %s is locked; cannot assign methods for function %s
zh_CN: 环境%s被锁住了；无法为函数%s指定方法

en: the 'where' environment (%s) is a locked namespace; cannot assign methods there
zh_CN: 'where'所指的环境(%s)是个锁住了的命名空间；因此无法在其中指定方法

en: Copying the generic function %s to environment %s, because the previous version was in a sealed namespace (%s)
zh_CN: 因为前版本是封閉了的命名空间(%3$s) ，所以将泛型函数%1$s拷贝到%2$s环境里

en: no existing definition for function %s
zh_CN: 函数%s没有定义

en: Creating a generic function from function %s in %s
zh_CN: 用%s里的函数%s来建立新的泛型函数

en: Creating a generic function for %s from package %s in %s
zh_CN: 从%3$s里的程序包%2$s为%1$s建立新的泛型函数

en: the method for function %s and signature %s is sealed and cannot be re-defined
zh_CN: 函数%s的方法和%s标记都被封闭了，因此无法将之重新定义

en: For function %s, signature %s: argument in method definition changed from (%s) to (%s)
zh_CN: %s函数，%s标记：方法定义中的参数由(%s)改成(%s)

en: primitive functions cannot be methods; they must be enclosed in a regular function
zh_CN: 基元函数不能是方法函数；它们必需被包含在一个正規函数里

en: invalid method definition: expected a function, got an object of class %s
zh_CN: 方法定义无效：提供的应该是函数，现在却是个类别为%s的对象

en: function supplied as argument 'f' must be a generic
zh_CN: 给参数'f'所提供的函数必需是泛型函数

en: no generic function %s found
zh_CN: 不存在%s这一泛型函数

en: no method found for function %s and signature %s
zh_CN: 找不到对函数%s和标记%s适用的方法

en: no environment or package corresponding to argument where=%s
zh_CN: 找不到与where=%s参数匹配的环境或程序包

en: no generic function found for '%s'
zh_CN: 找不到适合'%s'的泛型函数

en: no method found for function '%s' and signature %s
zh_CN: 函数'%s'和标记%s找不到方法

en: 'file' must be a character string or a connection
zh_CN: 'file'必需是字符串或联结

en: argument 'signature' is not meaningful with the current implementation and is ignored 
    (extract a subset of the methods list instead)
zh_CN: 'signature'参数对目前的实现没有意义，因此忽略不用
    (提取方法列表子集)

en: no method for %s matches class %s
zh_CN: %2$s类别里没有一个匹配%1$s的方法

en: no method found for signature %s
zh_CN: 标记%s里不存在任何方法

en: %s has no methods defined
zh_CN: %s没有设定任何方法

en: bad class specified for element %d (should be a single character string)
zh_CN: 为單元%d所设定的类别不正确(应当是条单字符字串)

en: first argument should be the names of one of more generic functions (got object of class %s)
zh_CN: 第一个参数应当为泛型函数的名称(现在却是类别为%s的对象)

en: must supply 'generic.function' or 'class'
zh_CN: 必须提供 'generic.function'或 'class'

en: %s is not an S4 generic function in %s; methods not removed
zh_CN: %s不是在%s里的S4泛型函数；因此方法没有被删除掉

en: cannot remove methods for %s in locked environment/package %s
zh_CN: 无法将锁住了的环境/程輯包%2$s里的%1$s方法删除

en: Restoring default function definition of %s
zh_CN: 重存%s的默認函数定义

en: error in updating S4 generic function %s; the function definition is not an S4 generic function (class %s)
zh_CN: 更新泛型函数%s时出了错；函数定义不是泛型函数(类别为%s)

en: Function %s is already a group generic; no change
zh_CN: 函数%s已经是群体泛型函数了；没有变动

en: Function %s is a group generic; do not call it directly
zh_CN: 函数%s是群体泛型函数；不能直接調用

en: callGeneric() must be called from within a method body
zh_CN: callGeneric() 必须从方法主体中调用

en: expected a non-empty character string for argument name
zh_CN: 参数的名称应该是非空字符串

en: generic function supplied was not created for %s
zh_CN: 所提供的泛型函数没有为%s建立

en: %s is a primitive function; its generic form cannot be redefined
zh_CN: %s是基元函数；其泛型形式是不能被重新定义的

en: %s is not currently a generic:  define it first to create a non-default implicit form
zh_CN: %s目前不是泛型函数：请先将之定义以建立一个非较默隐含形式

en: must provide an environment table; got class %s
zh_CN: 必需提供环境表；得到的是%s类别

en: original function is prohibited as a generic function
zh_CN: 原始函数是禁止作为泛型函数来用的

en: not both functions!
zh_CN: 不能同时用于两个函数!

en: argument %s is not S4
zh_CN: 参数%s不是S4

en: formal arguments differ (in default values?)
zh_CN: 正式参数不相对(默认值不一样？)

en: formal arguments differ: (%s), (%s)
zh_CN: 正式参数不相对: (%s), (%s)

en: value classes differ: %s, %s
zh_CN: 值类别不相对: %s, %s

en: signatures differ:  (%s), (%s)
zh_CN: 标记不相对: (%s), (%s)

en: package slots  differ: %s, %s
zh_CN: 程序包类型不相对: %s, %s

en: groups differ: %s, %s
zh_CN: 组不相对: %s, %s

en: generic names differ: %s, %s
zh_CN: 泛型名称不相对：%s, %s

en: argument %s must be a generic function or a single character string; got an object of class %s
zh_CN: 参数%s要么是泛型函数要么是单一字符串；现在得到的却是类别为%s的目标对象对象

en: non-generic function '%s' given to findMethods()
zh_CN: findMethods()不适用于非泛型函数'%s'

en: only FALSE is meaningful for 'inherited', when 'where' is supplied (got %s)
zh_CN: 只有 FALSE 对 'inherited' 有意义，当提供 'where' （得到 %s）

en: argument 'f' must be a generic function or %s
zh_CN: 参数'f'必需是泛型函数，或为%s

en: '%s' is not a known generic function {and 'package' not specified}
zh_CN: 没有'%s'这样一个泛型函数，{也没有设定'package'}

en: invalid first argument: should be the name of the first argument in the dispatch
zh_CN: 第一个参数无效: 应该是分配里的第一参数的名称

en: duplicate element names in 'MethodsList' at level %d: %s
zh_CN: 'MethodsList'里%d: %s水平上的單元名称有重复

en: element %d at level %d (class %s) cannot be interpreted as a function or named list
zh_CN: 水平%2$d上的%1$d單元(%3$s类别)既不是函数也不是命名列表

en: arguments 'names' and 'signature' must have the same length
zh_CN: 'names'和'signature'这两个参数的长度必需相同

en: inserting method with invalid signature matching argument '...' to class %s
zh_CN: 无法插入标记有错误的方法其参数'...'同类别%s相对应

en: inserting method corresponding to empty signature
zh_CN: 无法插入相对应于空标记的方法

en: inserting method into non-methods-list object (class %s)
zh_CN: 无法将方法插入非方法列表对象(类别为%s)

en: invalid method sublist
zh_CN: 方法子列表有错误

en: %f is not a valid generic function: methods list was an object of class %s
zh_CN: %f不是正确的泛型函数: 方法列表是类别为%s的对象

en: %s must be TRUE, FALSE, or a named logical vector of those values; got an object of class %s
zh_CN: %s的值必需为TRUE, FALSE, 或是个带名称的逻辑向量; 现在得到的却是类别为%s的对象

en: default method must be a method definition, a primitive or NULL: got an object of class %s
zh_CN: 缺省方法必需是方法定义，原始方法或NULL，得到的却是类别为%s的对象

en: trying to match a method signature to an object (of class %s) that is not a generic function
zh_CN: 无法将方法标记同一个不是泛型函数的对象(类别是%s)相对应起来

en: invalid 'package' slot or attribute, wrong length
zh_CN: 'package'类型或属性出了错，其长度无效

en: invalid element in a list for "signature" argument; element %d is neither a class definition nor a class name
zh_CN: "signature"参数里列表元素出了错；第%d个元素不是类别定义出不是类别名称

en: trying to match a method signature of class %s; expects a list or a character vector
zh_CN: 无法同类别为%s的方法标记相对应; 必需用列表或字符向量

en: object to use as a method signature for function %s does not look like a legitimate signature (a vector of single class names): there were %d class names, but %d elements in the signature object
zh_CN: 为函数%1$s作为方法标记而用的对象看来不象是合法的标记(单类别名称向量)：一共有%2$d类别名称，但标记对象里只有%3$d个元素

en: more elements in the method signature (%d) than in the generic signature (%d) for function %s
zh_CN: 用在函数%3$s上的方法标记(%1$d)里元素比泛型标记(%2$d)里的要多

en: no generic function found corresponding to %s
zh_CN: %s找不到泛型函数

en: skipping methods list element %s of unexpected class %s
zh_CN: 因为其类别%2$s没有定义，忽略%1$s这一方法列表單元

en: %s, along with other use of the "MethodsList" metadata objects, is deprecated.
zh_CN: %s和其他"MethodsList"元数据目标对象都已经不推荐使用了

en: In %s: use of "MethodsList" metadata objects is deprecated.
zh_CN: 在 %s 中： "MethodsList" 元数据对象即将被弃用.

en: Use %s instead.
zh_CN: 请改用%s。

en: %s, along with other use of the "MethodsList" metadata objects, is defunct.
zh_CN: %s 以及“MethodsList”元数据对象的其他用法已失效。

en: In %s: use of "MethodsList" metadata objects is defunct.
zh_CN: 在 %s 中：不再使用“MethodsList”元数据对象。

en: invalid object for formal method definition: type %s
zh_CN: 正式方法定义的对象无效: %s类型

en: missing package slot (%s) in object of class %s (package info added)
zh_CN: %2$s类别的对象里缺少程輯包类型(%1$s)(加入了程輯包信息)

en: 'initialize' method returned an object of class %s instead of the required class %s
zh_CN: 'initialize'方法回復了类别为%s的对象而不是所要求的%s这一类别

en: %d: target "%s": chose "%s" (others: %s)
zh_CN: %d: 目标"%s": 选择"%s" (其它：%s)

en: Notes: %s.
zh_CN: 记录：%s。

en: class generator function for class %s from package %s
zh_CN: 程序包"%2$s"里用于"%1$s"这一类的类生成函数

en: the names in signature for method (%s) do not match %s's arguments (%s)
zh_CN: 方法(%s)标记里的名称同函数%s参数(%s)不相对应

en: the names in signature for method (%s) do not match function's arguments (%s)
zh_CN: 方法 （%s） 的签名中的名称与函数的参数 （%s） 不匹配

en: a call to callNextMethod() appears in a call to %s, but the call does not seem to come from either a generic function or another 'callNextMethod'
zh_CN: callNextMethod()的调用是在調用%s时所要求的，但这一調用既不从泛型函数来，也从另外一个'callNextMethod'中来

en: call to 'callNextMethod' does not appear to be in a 'method' or 'callNextMethod' context
zh_CN: 調用'callNextMethod'既不在'method'也不在'callNextMethod'的文脈中出现

en: bad object found as method (class %s)
zh_CN: 作为方法的对象(类别%s)出了错

en: No next method available
zh_CN: 没有可用的下一个方法

en: in constructing the prototype for class %s: prototype has class %s, but the data part specifies class %s
zh_CN: 为类别%s建立原型时出了错：原型的类别是%s，但数据部分设定的类别是%s

en: in constructing the prototype for class %s, slots in prototype and not in class: %s
zh_CN: 为类别%s建立原型时出了错, 原型里有类型但类别里却没有: %s

en: in making the prototype for class %s elements of the prototype failed to match the corresponding slot class: %s
zh_CN: 为类别"%s"建立原型时出了错，原型的单元同类型的类别对应不上: %s

en: potential cycle in class inheritance: %s has duplicates in superclasses and subclasses (%s)
zh_CN: 类别继承里有可能有循环: %s在父类别和子类别(%s)里有重复

en: undefined slot classes in definition of %s: %s
zh_CN: 在%s的定义中不存在这类型型类别: %s

en: (class %s)
zh_CN: (类别%s)

en: in definition of class %s, information for superclass %s is of class %s (expected "SClassExtension")
zh_CN: 在类别%s的定义中有关于父类别%s的信息的类别是%s (所要求的则是"SClassExtension")

en: class %s extends an undefined class, %s
zh_CN: 类别%s不能擴充不存在的类别,%s

en: 'Class' must be a valid class definition or class
zh_CN: 'Class'必需是有效的类别名称或类别定义

en: trying to assign an object of class %s as the definition of class %s: must supply a "classRepresentation" object
zh_CN: 无法将类别为%s的对象指定成类别%s的定义：必需提供"classRepresentation"这种对象

en: assigning as %s a class representation with internal name %s
zh_CN: 无法将内部名称为%2$s的类别表現指定成%1$s

en: class %s has a locked definition in package %s
zh_CN: 类别%s在程輯包%s里的定义被锁住了

en: 'externalptr' objects cannot be initialized from new()
zh_CN: 'externalptr'对象无法从new()里来进行初始化

en: initializing objects from class %s with these arguments is not supported
zh_CN: 类别为%s的带这些参数的对象无法被初始化

en: in defining class %s, the supplied data part class, %s is not valid (must be a basic class or a virtual class combining basic classes)
zh_CN: 是设定类别%s时，所提供的数据部分类别, %s有错误(必需是基本类别或组合多个基本类别的虛擬类别)

en: no definition was found for superclass %s in the specification of class %s
zh_CN: 在定义%2$s里不存在母类别%1$s的定义

en: conflicting definition of data part: .Data = %s, superclass implies %s
zh_CN: 数据部分的定义相互有矛盾: .Data = %s，而父类别却意味着%s

en: a prototype object was supplied with object slot of class %s, but the class definition requires an object that is class %s
zh_CN: 原型对象与类别为%s的对象类型同时被提供，但类别定义要求类别为%s的对象

en: a prototype was supplied of class %s, but the class definition requires an object that is class %s
zh_CN: 被提供的原型的类别为%s, 类别定义需要类别为%s的对象

en: class %s extends an undefined class (%s)
zh_CN: 类别%s擴充不存在的类别(%s)

en: The prototype for class %s has undefined slot(s): %s
zh_CN: 类 %s 的原型具有未定义的插槽： %s

en: %s is not eligible to be the data part of another class (must be a basic class or a virtual class with no slots)
zh_CN: %s不可以成为另外一个类别的数据部分(必需是没有类型的基本类别或虛擬类别才可以)

en: prototype is a list with named elements (could be ambiguous):  better to use function prototype() to avoid trouble.
zh_CN: 原型是带名称單元的列表(允许有歧义) ：最好用函数prototype()以避免出错。

en: the '%s' list for class %s, includes an undefined class %s
zh_CN: 类别为%2$s的'%1$s'列表，包含不存在的类别%3$s

en: class %s is inheriting an inconsistent superclass structure from class %s, inconsistent with %s
zh_CN: %s类别从%s继承了有矛盾的超类别结构，与%s有矛盾

en: unable to find a consistent ordering of superclasses for class %s: order chosen is inconsistent with the superclasses of %s
zh_CN: 无法为类别%s找到相容的超类顺序: 所选择的顺序同%s超类不相容

en: "class" is a reserved slot name and cannot be redefined
zh_CN: "class"是为保留类型名，不可以重新被定义

en: Data part is undefined for general S4 object
zh_CN: 没有定义一般S4对象的数据部分

en: no '.Data' slot defined for class %s
zh_CN: 类别%s没有'.Data'这一个类型

en: class %s does not have a data part (a .Data slot) defined
zh_CN: 类别%s没有数据部分(.Data 类型)

en: more than one possible class for the data part: using %s rather than %s
zh_CN: 数据部分有多类型别：用%s而不用%s

en: class cannot have both an ordinary and hidden data type
zh_CN: 类别不能同时具有普通的和暗藏的数据类型

en: a validity method must be a function of one argument, got an object of class %s
zh_CN: 正确的方法必需的带一个参数的函数，收到的却是类别为%s的对象

en: unable to find required package %s
zh_CN: 找不到所需要的程輯包%s

en: unable to find an environment containing class %s
zh_CN: 找不到包含类别%s的环境

en: Note: some superclasses of class %s in package %s have duplicate definitions.  This definition is not being treated as equivalent to that from package %s
zh_CN: 注意：包 %s 中类 %s 的某些超类具有重复的定义。 此定义未被视为等效于包 %s 中的定义

en: Note: the specification for class %s in package %s seems equivalent to one from package %s: not turning on duplicate class definitions for this class.
zh_CN: 注意：包 %s 中类 %s 的规范似乎等同于包 %s 中的规范：不为此类打开重复的类定义。

en: Found more than one class "%s" in cache; using the first, from namespace '%s'
zh_CN: 在缓存中找到多个类“%s”;使用第一个，从命名空间 '%s'

en: Also defined by
zh_CN: 也被定义由

en: undefined subclass %s of class %s; definition not updated
zh_CN: %2$s类别的子类别%1$s没有定义；因此没有更新

en: no definition of inheritance from %s to %s, though the relation was implied by the setIs() from %s
zh_CN: 不存在从%s到"%s"类别的繼承定义，虽然%s的setIs()暗示其存在

en: Debugging .checkSubclasses(): assignClassDef(what="%s", *, where=%s, force=TRUE);
zh_CN: 调试 .checkSubclasses(): assignClassDef(what="%s", *, where=%s, force=TRUE);

en: argument 'includeSubclasses' must be a logical, either one value or a vector of the same length as argument 'classes'
zh_CN: 参数'includeSubclasses'必需是逻辑值，要么是单一值要么是向量，其长度应同参数'classes'相等

en: argument 'abbreviate' must be 0, 1, 2, or 3
zh_CN: 参数'abbreviate'必需为0，1，2，或3

en: needed the supplied labels vector of length %d, got %d
zh_CN: 需要的是长度为%d而不是%d的标签向量

en: the function being used as %s in making a generic function for %s is currently traced; the function used will have tracing removed
zh_CN: 在为%2$s制造泛型函数时用的%1$s这一个函数现在已经被追踪；因此删除了对所用函数的追踪

en: must supply either a generic function or a function as default for %s
zh_CN: 必需为%s提供一个作默认用的泛型函数或函数

en: the %s argument must be NULL or a generic function object; got an object of class %s
zh_CN: %s的参数要么是NULL，要么是泛型函数对象；现在却是类别为%s的对象

en: no suitable arguments to dispatch methods in this function
zh_CN: 此函数里没有合适的参数可用来分配方法

en: making a generic for special function %s
zh_CN: 为特殊函数 %s制造泛型函数

en: in method for %s with signature %s:
zh_CN: 带%s标记的%s的方法：

en: formal arguments in method and generic do not appear in the same order
zh_CN: 方法正式参数和泛型方法正式参数的顺序不同

en: formal arguments (%s) omitted in the method definition cannot be in the signature
zh_CN: 方法定义里所忽略的正式参数(%s)不能存在于标记

en: expanding the signature to include omitted arguments in definition: %s
zh_CN: 在定义里扩展标记来包括进忽略了的参数：%s

en: methods can add arguments to the generic %s only if '...' is an argument to the generic
zh_CN: 只有当'...'是泛型方法参数时方法才能给泛型%s加参数

en: argument 'f' must be a string, generic function, or primitive: got an ordinary function
zh_CN: 'f'参数要么是字符，要么是泛型函数，要么是原始函数：现在得到的却是普通函数

en: no generic function found for %s
zh_CN: 为'%s'找不到泛型函数

en: Empty function name in .getGeneric
zh_CN: .getGeneric里不能有空的函数名称

en: no methods found for %s; cacheGenericsMetaData() will have no effect
zh_CN: %s找不到方法；'cacheGenericsMetaData()'没有作用

en: invalid value from generic function %s, class %s, expected %s
zh_CN: 类别为%2$s的泛型函数'%1$s'的值无效, 所要求的是%3$s

en: the body of the generic function for %s calls 'standardGeneric' to dispatch on a different name ("%s")!
zh_CN: '%s'泛型函数的程序部分調用'standardGeneric'来分配给一个不同的名称("%s")!

en: trying to change the formal arguments in %s in an object of class %s; expected a function definition
zh_CN: %s里在类别为%s的对象中是不能改变其正式参数的；所需要的是函数定义

en: trying to change the formal arguments in %s, but getting the new formals from an object of class %s; expected a function definition
zh_CN: 无法在%s中改变正式参数，因为从类别为%s的对象里得到的是新的正式参数；所需要的是函数定义

en: trying to change the formal arguments in %s, but the number of existing arguments is less than the number of new arguments: (%s) vs (%s)
zh_CN: 无法在%s中改变正式参数，因为存在的参数数目比新的参数数目要小：(%s)比(%s)

en: trying to change the formal arguments in %s, but the number of existing arguments is greater than the number of new arguments (the extra arguments won't be used): (%s) vs (%s)
zh_CN: 无法在%s中改变正式参数，因为存在的参数数目比新的参数数目要大(额外的变无是不能用的): (%s)比(%s)

en: in changing formal arguments in %s, some of the old names are not in fact arguments: %s
zh_CN: 在%s中改变正式参数时，一些旧的参数名称其实不是参数: %s

en: got a negative maximum number of frames to look at
zh_CN: 框的最大数不能是负值

en: %s is not a generic function (or not visible here)
zh_CN: %s不是泛型函数(或从这儿看不到)

en: invalid element in the "groupMembers" slot (class %s)
zh_CN: "groupMembers"类型里的單元无效(类别为%s)

en: argument f must be a generic function with signature "..."
zh_CN: 参数f必需是带"..."标记的泛型函数

en: no method or default matching the "..." arguments in %s
zh_CN: %s里没有同"..."参数匹配的方法或默认值

en: multiple direct matches: %s; using the first of these
zh_CN: 有多个直接的匹配:%s；用第一个

en: multiple equivalent inherited matches: %s; using the first of these
zh_CN: 多条等价继承安匹配: %s；用第一个

en: single string; got an object of class %s
zh_CN: 单独字符串：不该是类别为%s的对象

en: multiple definitions exist for class %s, but the supplied package (%s) is not one of them (%s)
zh_CN: %s类别存在多个定义，但提供的程序包（%s）不是其中之一（%s）

en: multiple definitions exist for class %s; should specify one of them (%s), e.g. by className()
zh_CN: %s类别存在多个定义；应该指定用一个(%s)，比如通过className()

en: no definition found for class %s
zh_CN: 类别%s的定义不存在

en: missing function for load action: %s
zh_CN: 荷载操作时找不到函数：%s

en: error in load action %s for package %s: %s: %s
zh_CN: 为程序包%2$s荷载操作%1$s时出了错：%3$s: %4$s

en: non-function action: %s
zh_CN: 非函数操作：%s

en: action function %s has no arguments, should have at least 1
zh_CN: 操作函数%s没有参数，至少应该有一个

en: some actions are missing: %s
zh_CN: 有些操作缺失：%s

en: %s has a sealed class definition and cannot be redefined
zh_CN: %s的类别定义被封闭了，因此无法重新被定义

en: Argument "representation" cannot be used if argument "slots" is supplied
zh_CN: 如果已经提供了"slots"参数的话，"representation"参数就不能用了

en: only arguments 'Class' and 'where' can be supplied when argument 'representation' is a 'classRepresentation' object
zh_CN: 当参数'representation'是'classRepresentation'对象时只能使用'Class'和'where'变元

en: error in contained classes (%s) for class %s and unable to remove definition from %s
zh_CN: %2$s类别里包含的子类别(%1$s)不正确，但无法将定义从%3$s中删除

en: error in contained classes (%s) for class %s; class definition removed from %s
zh_CN: %2$s类别里包含的子类别(%1$s)不正确；类别定义从%3$s中被删除

en: error in contained classes (%s) for class %s and unable to restore previous definition from %s
zh_CN: %2$s类别里包含的子类别(%1$s)不正确，但无法将%3$s中原来的定义重新储存

en: error in contained classes (%s) for class %s; previous definition restored to %s
zh_CN: %2$s类别里包含的子类别(%1$s)不正确；原来的定义重新储存到%3$s中

en: element %d of the representation was not a single character string
zh_CN: 表现的%d單元不是单字符的字串

en: duplicate class names among superclasses: %s
zh_CN: 父类别里有重复的类别名: %s

en: only one data object (unnamed argument to prototype) allowed
zh_CN: 只能有一个数据对象(原型的参数没有名称)

en: %s is not a defined class
zh_CN: %s不是有定义的类别

en: %s is not a slot in class %s
zh_CN: %s不是在%s类别里的类型

en: assignment of an object of class %s is not valid for slot %s in an object of class %s; is(value, "%s") is not TRUE
zh_CN: 不可以在类别为%3$s的对象里的%2$s类型指定类别为%1$s的对象；is(value, "%4$s")的值不是TRUE

en: assignment of an object of class %s is not valid for @%s in an object of class %s; is(value, "%s") is not TRUE
zh_CN: 不可以在类别为%3$s的对象里的@%2$s类型指定类别为%1$s的对象；is(value, "%4$s")的值不是TRUE

en: class definition for %s not found (no action taken)
zh_CN: 找不到%s类别定义(无效)

en: class %s has multiple definitions visible; only the first removed
zh_CN: 类别%s有多个定义；只删除了第一个

en: invalid class %s object
zh_CN: 类别为%s的对象无效

en: validity method must be NULL or a function of one argument
zh_CN: 正确的方法要么是NULL要么是带一个参数的函数

en: class %s not found on %s; 'resetClass' will have no effect
zh_CN: 类别%s不存在于%s中；因此'resetClass'没有任何作用

en: argument 'classDef' must be a string or a class representation; got an object of class %s
zh_CN: 参数'classDef'要么是个字串要么是个类别表现；现在得到的却是类别为%s的目标对象

en: class %s is sealed; 'resetClass' will have no effect
zh_CN: 类别%s被封闭了；因此'resetClass'没有任何作用

en: cannot use object of class %s in new():  class %s does not extend that class
zh_CN: 无法在new()里用类别为%s的对象；类别%s并不擴充此类别

en: duplicated slot names: %s
zh_CN: 重复类型名: %s

en: class %s is defined, with package %s, but no corresponding metadata object was found (not exported?)
zh_CN: %s类别已经在%s程序包里被定义过了，但没有与之相对应的元数据对象(有没有被导出过？)

en: no definition of %s to use for %s
zh_CN: %s没有定义，不能为%s起作用

en: class definition cannot extend more than one of these data types: %s
zh_CN: 类别定义最多只能扩展这些数据类型中的一个: %s

en: abnormal type %s is not supported as a superclass of a class definition
zh_CN: 不支持作为一个类别定义的超类%s

en: multiple class definitions for %s from packages: %s; picking the first
zh_CN: 程序包:%2$s里有多个类别%1$s的定义；现在用第一个

en: no package name supplied and no class definition found for %s
zh_CN: 没有程序包也没有给%s做的类别定义

en: argument 'classDef' must be a class definition or the name of a class
zh_CN: 参数'classDef'必需是类别定义或是类别的名称

en: No %s names supplied
zh_CN: 没有提供%s名称

en: All %s names must be nonempty in:
    (%s)
zh_CN: 所有%s的名称都不能是空的：
    (%s)

en: All %s names must be distinct in:
    (%s)
zh_CN: 所有%s的名称都必需是不同的：
    (%s)

en: argument %s must be a list or a character vector; got an object of class %s
zh_CN: 参数%s要么是列表要么是单一字符串；现在得到的却是类别为%s的目标对象

en: no function %s found
zh_CN: 找不到%s这一函数

en: no non-generic function %s found
zh_CN: 找不到%s这一非泛型函数

en: %s is not one of the element names
zh_CN: %s不是單元名称中的一个

en: no method or default for coercing %s to %s
zh_CN: 没有可以用来強制转换%s成%s的方法或默认函数

en: no method or default for as() replacement of %s with Class="%s"
zh_CN: 没有可用于Class="%2$s"as()"%1$s"替换值的方法或默認函数

en: trying to set an 'as' relation from %s to itself
zh_CN: 无法为%s与自己设立'as'关系

en: class %s is not defined in this environment
zh_CN: 类别%s在这个环境里没有定义

en: class %s is a class union: 'coerce' relations to a class union are not meaningful
zh_CN: 类别%s是类别併集：类别併集的'coerce'关系在这里没有意义

en: 'as' method should have one argument, or match the arguments of coerce(): got  (%s)
zh_CN: 'as'方法必需有一个参数，或同coerce()相对应，得到的却是(%s)

en: a 'replace' method definition in 'setAs' must be a function of two arguments, got %d
zh_CN: 'setAs'中的'replace'方法定义必需是带两个参数的函数，得到的却是%d

en: argument names in 'replace' changed to agree with 'coerce<-' generic:
    %s
zh_CN: 'replace'里的参数名称得到了修改使之与'coerce<-'泛型相符合:
    %s

en: ambiguous object (length != 1) to coerce to "name"
zh_CN: 对象不明确(长度!=1) 因此无法强制转换成"name"

en: undefined 'coerce' method
zh_CN: 没有'coerce'方法

en: methods currently exist for coercing from %s to %s; they will be replaced.
zh_CN: 目前存在着強制转换%s成%s的方法；这些方法将会被替换掉。

en: object %s not found
zh_CN: 找不到%s这个对象

en: object %s not changed (it is not consistent with the current definition of class %s from %s)
zh_CN: 对象%1$s没有变动(它与%3$s里类别为%2$s的目前定义不相符合)

en: no definition for the class of %s (class %s) found
zh_CN: 类别为%s的定义不存在(类别%s)

en: object %s not changed (it does not appear to be from a version of R earlier than 1.8.0)
zh_CN: 对象%s没有变动(它不是从R版本1.8.0之前来的)

en: 'class1' must be the name of a class or a class definition
zh_CN: 'class1'必需是类别名称或类别定义

en: 'class2' must be the name of a class or a class definition
zh_CN: 'class2'必需是类别名称或类别定义

en: class %s has no visible definition from package or environment %s
zh_CN: 类别%s在程輯包或环境%s里没有看得见的定义

en: cannot create a 'setIs' relation when neither of the classes (%s and %s) is local and modifiable in this package
zh_CN: 无法建立'setIs'这个关系，因为两个类别(%s和%s)都不是局部性的，也不能在程輯包进行改动

en: class %s is sealed; new superclasses can not be defined, except by 'setClassUnion'
zh_CN: 类别%s被封闭了；除了'setClassUnion'之外无法设定新的父类别

en: class %s cannot extend class %s
zh_CN: 类别%s无法擴充类别%s

en: both classes must be defined
zh_CN: 两个类别都得有定义

en: invalid index for function argument
zh_CN: 函数参数的索引无效

en: no function definition found for %s
zh_CN: 没有%s函数定义

en: need a definition for the method here
zh_CN: 这里需要方法定义

en: Skeleton of method written to %s
zh_CN: 方法骨架写于%s

en: invalid object in meta table of methods for %s, label %s, had class %s
zh_CN: 元方法表里方法%1$s，标签%2$s的对象无效，类别不应该是%3$s

en: bad method object stored in method table, class %s
zh_CN: 作为方法的对象(类别是%s)出错

en: invalid object in methods table (%s), expected a method, got an object of class %s
zh_CN: 方法表(%s)里的对象定义无效：应该是方法，现在却是个类别为%s的对象

en: trying to find a methods table in a non-generic function
zh_CN: 在非泛型函数里是找不到方法列表的

en: the "ambiguousMethodSelection" option should be a function to be called as the condition action; got an object of class %s
zh_CN: "ambiguousMethodSelection"这个选项应该是作为条件来调用的函数；现在它却是类别为%s的对象

en: No simply inherited methods found for function %s; using non-simple method
zh_CN: 找不到适用于函数%s的简单方法；用复杂方法

en: Note: method with signature %s chosen for function %s,
     target signature %s.
     %s would also be valid
zh_CN: 注意: 为函数"%2$s"选择了带"%1$s"标签的方法,
     目标标签为"%3$s".
     %4$s应该是有效的

en: unable to find an inherited method for function %s for signature %s
zh_CN: 函数%s标签%s找不到继承方法

en: failed to find expected group generic function:
zh_CN: 找不到需要的团体泛型函数：

en: invalid group generic function in search for inherited method (class %s)
zh_CN: 在找继承方法时出现的团体泛型函数无效（类别%s）

en: invalid methods table request
zh_CN: 方法表要求出错

en: trying to check signature length of group generic '%s', but it is not a group generic
zh_CN: 检查团体泛型'%s'的标记长度，但它不是团体泛型

en: trying to check signature length of generic '%s', but it is not a generic function: i = %d, funs = %s, gnames = %s
zh_CN: 检查泛型'%s'的标记长度，但它不是团体泛型function: i = %d, funs = %s, gnames = %s

en: no methods table for generic %s from package %s in package %s
zh_CN: 在%3$s程序包中程序包%2$s里的泛型%1$s没有方法列表

en: undefined classes (%s) will be ignored for argument '%s'
zh_CN: 参数'%2$s'里没有定义的类别(%1$s)会被忽略不用

en: argument 'signatures' must be a character matrix whose rows are method signatures
zh_CN: "signatures"参数必需为字符矩阵，每行里都是标签方法

en: not allowed to have test==TRUE and an S4Class definition
zh_CN: test==TRUE和S4Class定义不能同时存在

en: argument 'S4Class' must be a class definition: got an object of class %s
zh_CN: 参数'S4Class'必需是类别定义：现在得到的却是类别为%s的目标对象

en: inconsistent old-style class information for %s; the class is defined but does not extend %s and is not valid as the data part
zh_CN: %s旧式类别信息有矛盾；虽然类别的定义是存在的，但它不扩展%s而且也不能当作数据来用

en: the S3 class of the prototype, "%s", is undefined; only allowed when this is the S3 class being registered ("%s")
zh_CN: S3类别的原型, "%s", 没有定义；只有在注册这个S3类别时才允许这种情况("%s")

en: restoring definition of class %s
zh_CN: 恢复类别%s的定义

en: slot %s: class %s should extend class %s
zh_CN: 类型%s：类别%s无法扩充类别%s

en: invalid S4 class corresponding to S3 class: slots in  S4 version must extend corresponding slots in S3 version: fails for %s
zh_CN: 与S3类别相对应的S4类别无效：S4类别里的类型必需擴充类别S3中相应的类型：%s出了错

en: explicit coercion of old-style class (%s) is not defined
zh_CN: 旧式类别(%s)的明确强制转换没有定义

en: explicit replacement not defined for as(x, "%s") <- value for old-style class %s
zh_CN: 用于旧式类别%2$s的as(x, "%1$s") <- value的替换值没有明确的定义

en: argument 'Classes' must be a vector of two classes; got an argument of length %d
zh_CN: 参数'classes'必需是包含两个类别的向量；现在得到的是长度为%d的参数

en: inconsistent old-style class information for %s (maybe mixing old and new classes?)
zh_CN: %s旧式类别信息有矛盾(会不会是将旧的和新的类别混在了一起用?)

en: 'S3Class' only defined for extensions of %s or classes with a data part:  not true of class %s
zh_CN: 'S3Class'只能定义于为%s扩充或带数据部分的类别，不适用于类别%s

en: 'S3Class' can only assign to S4 objects that extend "oldClass"; not true of class %s
zh_CN: 'S3Class'只能分配给扩充"oldClass"类别的S4目标对象；不适用于类别%s

en: Created a package name, %s, when none found
zh_CN: 建立了程輯包名: %s，因为没有找到其它名称

en: no definition of class %s found
zh_CN: 类别%s的定义不存在

en: multiple definitions of %s found; using the one on %s
zh_CN: %s有多个定义；用%s这一个

en: %s is not a valid field or method name for reference class %s
zh_CN: "%s"场要么无效，要么引用类%s的方法名不正确

en: a call to superClass() is in the method %s but there is no superclass definition of this method for class %s
zh_CN: 在%s方法里调用了superClass()，但是%s类别里没有这个方法的超类别定义

en: methods declared in usingMethods() but not found: %s
zh_CN: usingMethods()里有方法的声明，但找不到：%s

en: %s is not a reference class
zh_CN: %s不是引用类别

en: %s is not a field in class %s
zh_CN: %s不是在%s类别里的场

en: unnamed arguments to $new() must be objects from a reference class; got an object of class %s
zh_CN: $new()里没有名称的参数必需是从引用类来的对象；现在得到的却是类别%s的对象

en: %s is not a valid field or method name for this class
zh_CN: %s不是个有效的场，也不是这个类别的方法名称

en: the class of field %s in the object is not compatible with the desired class %s in the target
zh_CN: %s对象场类别不符合目标中%s类别的需要

en: %s is not a defined class in this environment
zh_CN: %s在这个环境里没有类别定义

en: invalid 'Class' argument:  should be a single string
zh_CN: 'Class'参数无效：应当是单字符字串

en: %s is not one of the reference super classes for this object
zh_CN: %s不是该对象的引用超类之一

en: direct calls to callSuper() are invalid:  should only be called from another method
zh_CN: 不能直接调用callSuper()：只能用其它的方法来调用它

en: %s is not a field in this class
zh_CN: %s不是这个类别里的场

en: the definition of class %s in package %s is locked, methods may not be redefined
zh_CN: 程序包%2$s中%1$s类别的定义封闭了，因此无法将方法重新定义

en: arguments to methods() must be named, or one named list
zh_CN: methods()里的参数必需带名称，或者是带名称的列表

en: topic %s is not a method name in class %s
    The class definition follows
zh_CN: %s主题在%s类别里不是方法名称
    类别定义在下面

en: the definition of class %s in package %s is locked so fields may not be modified
zh_CN: 程序包%2$s中%1$s类别的定义封闭了，因此无法修改场的定义

en: the overriding class ("%s") of field %s is not a subclass of the existing field definition ("%s")
zh_CN: 场%2$s的首要类("%1$s")不是已经存在了的场定义的子类别("%3$s")

en: the 'contains' argument should be the names of superclasses:  got an element of class %s
zh_CN: 'contains'参数应当是超类别的名称(现在却是类别为%s的对象)

en: no definition found for inherited class: %s
zh_CN: 继承类别的定义不存在: %s

en: a single class name is needed for field %s, got a character vector of length %d
zh_CN: %s场需要单一类别名称，现在得到的是长度为%d的字符串

en: class %s for field %s is not defined
zh_CN: 场%2$s的类别%1$s还没有定义

en: field %s was supplied as an object of class %s; must be a class name or a binding function
zh_CN: 场%s被提供了类别%s的对象;但它必须是类别名或绑定函数

en: code for methods in class %s was not checked for suspicious field assignments (recommended package %s not available?)
zh_CN: 没有检查%s类别方法代码可能有错误的场赋值（是不是因为没有推荐程序包%s？）

en: class %s is defined but is not a reference class
zh_CN: 类别%s有定义但不是引用类别

en: class must be a reference class representation or a character string; got an object of class %s
zh_CN: 类别必需是引用类别或字符串；现在得到的却是类别为%s的目标对象

en: not a reference class: %s
zh_CN: 非引用类别: %s

en: local assignment to field name will not change the field:
        %s
     Did you mean to use "<<-"? ( in method %s for class %s)
zh_CN: 场名本地赋值不会改变场的内容：
        %1$s
     你意思是不是用"<<-"? (在类别%3$s的%2$s方法里)

en: non-local assignment to non-field names (possibly misspelled?)
        %s
    ( in method %s for class %s)
zh_CN: 非本地赋值非场名(是不是你写错了？)
        %1$s
    (在类别%3$s的%2$s方法里)

en: non-local assignment to method names is not allowed
        %s
    ( in method %s for class %s)
zh_CN: 不行允许非本地赋值方法名称
        %1$s
    (在类别%3$s的%2$s方法里)

en: arguments must all be character string names of fields
zh_CN: 参数必需是场名称的字符串

en: field %s is already locked
zh_CN: 场%s已经被锁住了

en: field %s of class %s has a non-default binding and cannot be locked
zh_CN: %1$s类别的%2$s场有非默认的约束力，因此不能被锁定

en: Class %s is not a subclass of %s; functional semantics not defined for this class
zh_CN: %s类别不是%s的子类别；这没有功能语义定义

en: Could not find local object in supplied environment
zh_CN: 无法在所提供的环境找到本地对象

en: invalid 'ignore' argument; should be a class definition or a character vector, got an object of class %s
zh_CN: 'ignore'参数无效，它要么是类别定义，要么是字符串；现在得到的却是类别为%s的对象

en: An object of class %s
zh_CN: 为类别为%s的对象

en: invalid call to 'classLabel': expected a name or a class definition, got an object of class %s
zh_CN: 'classLabel'调用无效：需要的是个名称或类别定义，但得到的却是类别为%s的目标对象

en: argument 'signature' is not meaningful for tracing reference methods
zh_CN: 'signature'参数不能适用于跟踪引用方法

en: %s is not a method for reference class %s
zh_CN: %s不是适用于引用类别%s的方法

en: argument 'what' should be the name of a function
zh_CN: 参数'what'必需是一个函数名称

en: tracing the internal function %s is not allowed
zh_CN: 不可以对内部函数%s进行跟踪

en: no function definition for %s found
zh_CN: 没有%s这样一个函数定义

en: cannot untrace method for %s; no method defined for this signature: %s
zh_CN: 无法将%s删除追踪；这一标记没有与之相对应的方法：%s

en: the method for %s for this signature was not being traced
zh_CN: 此标记的%s方法没有被追踪

en: the editing in trace() can only change the body of the function; got an object of class %s
zh_CN: trace()里的编辑只能用来改变函数主文；现在得到的却是类别为%s的对象

en: the editing in trace() can only change the body of the function, not the arguments or defaults
zh_CN: 追踪()里的编辑只能用来改变函数主文，不能用于参数默認值

en: cannot use 'at' argument without a trace expression
zh_CN: 不能用'at'这个参数，因为没有追踪表式

en: cannot use 'at' argument unless the function body has the form '{ ... }'
zh_CN: 不能用'at'这个参数，除非函数的主文有'{ ... }'这样的形式

en: assigning over the binding of symbol %s in environment/package %s
zh_CN: 在环境/程輯包 %2$s将符号%1$s的連結重新设定

en: setting a method over the binding of symbol %s in environment/package %s
zh_CN: 在环境/程輯包%2$s里将符号%1$s的连结重新进行了方法设定

en: Environment of class %s is locked; using global environment for new class
zh_CN: 类别为%s的环境被锁住了；为新的类别用全局环境

en: none of the objects in the source code could be found:  need to attach or specify the package
zh_CN: 在源代码中找不到任何对象：需要附加或指定程序包

en: objects found in multiple packages: using %s and ignoring %s
zh_CN: 在多个程序包中找到了对象：用%s而不用%s

en: package %s is not attached and no namespace found for it
zh_CN: %s程序包没有被附加，也找不到它的命名空间

en: invalid 'source' argument: expected file names or a connection but got an object of class %s
zh_CN: 'source'参数无效：应该是文件名称或链接，现在却是类别为%s的对象

en: cannot find an environment corresponding to package name '%s"
zh_CN: 找不到对应的环境于程序包'%s"

en: supplied package, %s, differs from package inferred from source, %s
zh_CN: 提供的程序包，%s，与从来源推断出的程序包，%s，不一样

en: cannot insert these (not found in source): %s
zh_CN: 这些无法插入（在源码中找不到）：%s

en: cannot insert methods for these functions (methods table not found in source): %s
zh_CN: 无法为这些函数插入方法（源码里找不到方法表）:%s

en: Non-function objects are not currently inserted (not traceable): %s
zh_CN: 目前没有插入非函数对象（不可追溯）: %s

en: New functions are not currently inserted (not untraceable): %s
zh_CN: 目前没有插入新函数（不可追溯）: %s

en: Modified functions inserted through trace(): %s
zh_CN: 用trace()插入修改过的函数: %s

en: %s() is not a generic function in the target environment -- methods will not be inserted
zh_CN: %s()不是在目标环境里的泛型函数--因此方法没有被插入

en: Methods inserted for function %s(): %s
zh_CN: 为函数%s()插入了方法: %s

en: no definition for object %s found in tracing environment
zh_CN: 在追溯环境里找不到%s对象的定义

en: multiple generics match pattern, using table %s
zh_CN: 有多个泛型同模式相匹配，用表%s

en: does not seem to be a method table for generic %s in tracing environment
zh_CN: 在追溯环境里找不到%s泛型函数的方法表

en: no method in methods table for %s for signature %s
zh_CN: 函数%s标记%s方法表里没有设定方法

en: unloading 'methods' package ...
zh_CN: 卸载'methods'程序包

en: apparently bad method or class metadata in saved environment;
zh_CN: 保存的环境中出现了不良方法或类别元数据;

en: move the file or remove the class/method
zh_CN: 移动文件或删除类别/方法

en: no definition for class %s | no definition for classes %s
zh_CN[0]: 类别%s的定义不存在

en: in the method signature for function %s invalid argument name in the signature: %s | in the method signature for function %s invalid argument names in the signature: %s
zh_CN[0]: 在函数%s里的方法标记中标记的参数名称无效: %s

en: Reported %d ambiguous selection out of %d for function %s
     | Reported %d ambiguous selections out of %d for function %s
zh_CN[0]: 函数%3$s里%2$d个选择有%1$d是歧义的

en: named elements of prototype do not correspond to slot name: %s | named elements of prototype do not correspond to slot names: %s
zh_CN[0]: 原型的命名單元同类型的名称对应不上: %s

en: non-argument found in the signature: %s | non-arguments found in the signature: %s
zh_CN[0]: 标记里出现了非参数：%s

en: the formal argument of the generic function for %s (%s) differs from that of the non-generic to be used as the default (%s) | the formal arguments of the generic function for %s (%s) differ from those of the non-generic to be used as the default (%s)
zh_CN[0]: 用于%s泛型函数(%s)的正式参数与将作为默認值(%s)来用的非泛型的正式参数不相符合

en: duplicated slot name: %s | duplicated slot names: %s
zh_CN[0]: 重复类型名: %s

en: invalid name for slot of class %s: %s | invalid names for slots of class %s: %s
zh_CN[0]: 类别%s的类型的名称无效：%s

en: multiple definition of class %s visible (%s); using the definition
       in package %s for %s | multiple definitions of class %s visible (%s); using the definition
       in package %s for %s
zh_CN[0]: 看得到%s有多个定义(%s)；现在用程序包%s中%s的定义

en: class %s is missing slot from class %s (%s), and no coerce method was supplied | class %s is missing slots from class %s (%s), and no coerce method was supplied
zh_CN[0]: 类别%s在类别%s(%s)中缺少类型，找不到强制方法

en: slot in class %s must extend corresponding slot in class %s: fails for %s | slots in class %s must extend corresponding slots in class %s: fails for %s
zh_CN[0]: 类别%s里的类型必需擴充类别%s中相应的类型：%s出了错

en: found %d equally good next method | found %d equally good next methods
zh_CN[0]: 找到了%d个同样有效的方法

en: Selecting %d method of minimum distance | Selecting %d methods of minimum distance
zh_CN[0]: 选用最小距离%d方法

en: Selecting %d non-group method | Selecting %d non-group methods
zh_CN[0]: 选用%d非组方法

en: Selecting %d partially exact-matching method | Selecting %d partially exact-matching methods
zh_CN[0]: 选用%d部分精密匹配方法

en: Choosing method %s from %d ambiguous possibility | Choosing method %s from %d ambiguous possibilities
zh_CN[0]: 从%2$d个歧义可能选择中选%1$s方法

en: no definition of class %s in the specified position, %s, definition on : %s | no definition of class %s in the specified position, %s, definitions on : %s
zh_CN[0]: 在指定的%2$s这个位置不存在类别%1$s的定义, 定义在: %3$s
