openstack入门之swift基础二：三种存储类型比较
我的图书馆
openstack入门之swift基础二：三种存储类型比较
&本帖最后由 pig2 于
18:51 编辑
1.块存储包含几种存储方式
块存储和文件存储是我们比较熟悉的两种主流的存储类型，而对象存储（Object-based Storage）是一种新的网络存储架构，基于对象存储技术的设备就是对象存储设备（Object-based Storage Device）简称OSD。
& && &&&首先，我们介绍这两种传统的存储类型。通常来讲，所有磁盘阵列都是基于Block块的模式，而所有的NAS产品都是文件级存储。
& && &&&以下列出的两种存储方式都是块存储类型：
& && &&&1） DAS（Direct Attach STorage）：是直接连接于主机服务器的一种储存方式，每一台主机服务器有独立的储存设备，每台主机服务器的储存设备无法互通，需要跨主机存取资料时，必须经过相对复杂的设定，若主机服务器分属不同的操作系统，要存取彼此的资料，更是复杂，有些系统甚至不能存取。通常用在单一网络环境下且数据交换量不大，性能要求不高的环境下，可以说是一种应用较为早的技术实现。
& && &&&2）SAN（Storage Area Network）：是一种用高速（光纤）网络联接专业主机服务器的一种储存方式，此系统会位于主机群的后端，它使用高速I/O 联结方式， 如 SCSI, ESCON 及 Fibre- Channels。一般而言，SAN应用在对网络速度要求高、对数据的可靠性和安全性要求高、对数据共享的性能要求高的应用环境中，特点是代价高，性能好。例如电信、银行的大数据量关键应用。它采用SCSI 块I/O的命令集，通过在磁盘或FC（Fiber Channel）级的数据访问提供高性能的随机I/O和数据吞吐率，它具有高带宽、低延迟的优势，在高性能计算中占有一席之地，但是由于SAN系统的价格较高，且可扩展性较差，已不能满足成千上万个CPU规模的系统。
2、文件存储
& && &&&通常，NAS产品都是文件级存储。&&NAS（Network Attached Storage）：是一套网络储存设备，通常是直接连在网络上并提供资料存取服务，一套 NAS 储存设备就如同一个提供数据文件服务的系统，特点是性价比高。例如教育、政府、企业等数据存储应用。
& && &&&它采用NFS或CIFS命令集访问数据，以文件为传输协议，通过TCP/IP实现网络化存储，可扩展性好、价格便宜、用户易管理，如目前在集群计算中应用较多的NFS文件系统，但由于NAS的协议开销高、带宽低、延迟大，不利于在高性能集群中应用。
& &&&下面，我们对DAS、NAS、SAN三种技术进行比较和分析：
表格 1 三种技术的比较
针对Linux集群对存储系统高性能和数据共享的需求，国际上已开始研究全新的存储架构和新型文件系统，希望能有效结合SAN和NAS系统的优点，支持直接访问磁盘以提高性能，通过共享的文件和元数据以简化管理，目前对象存储系统已成为Linux集群系统高性能存储系统的研究热点，如Panasas公司的Object Base Storage Cluster System系统和Cluster File Systems公司的Lustre等。下面将详细介绍对象存储系统。
3、对象存储
& && &&&总体上来讲，对象存储同兼具SAN高速直接访问磁盘特点及NAS的分布式共享特点。
& && &&&核心是将数据通路（数据读或写）和控制通路（元数据）分离，并且基于对象存储设备（Object-based Storage Device，OSD）构建存储系统，每个对象存储设备具有一定的智能，能够自动管理其上的数据分布。
& && &&&对象存储结构组成部分（对象、对象存储设备、元数据服务器、对象存储系统的客户端）：
& && &&&3.1、对象
& && &&&对象是系统中数据存储的基本单位，一个对象实际上就是文件的数据和一组属性信息（Meta Data）的组合，这些属性信息可以定义基于文件的RAID参数、数据分布和服务质量等，而传统的存储系统中用文件或块作为基本的存储单位，在块存储系统中还需要始终追踪系统中每个块的属性，对象通过与存储系统通信维护自己的属性。在存储设备中，所有对象都有一个对象标识，通过对象标识OSD命令访问该对象。通常有多种类型的对象，存储设备上的根对象标识存储设备和该设备的各种属性，组对象是存储设备上共享资源管理策略的对象集合等。
& && & 3.2、对象存储设备
& && &&&对象存储设备具有一定的智能，它有自己的CPU、内存、网络和磁盘系统，OSD同块设备的不同不在于存储介质，而在于两者提供的访问接口。OSD的主要功能包括数据存储和安全访问。目前国际上通常采用刀片式结构实现对象存储设备。OSD提供三个主要功能：
& && &（1） 数据存储。OSD管理对象数据，并将它们放置在标准的磁盘系统上，OSD不提供块接口访问方式，Client请求数据时用对象ID、偏移进行数据读写。& && &（2） 智能分布。OSD用其自身的CPU和内存优化数据分布，并支持数据的预取。由于OSD可以智能地支持对象的预取，从而可以优化磁盘的性能。& && &（3） 每个对象元数据的管理。OSD管理存储在其上对象的元数据，该元数据与传统的inode元数据相似，通常包括对象的数据块和对象的长度。而在传统的NAS系统中，这些元数据是由文件服务器维护的，对象存储架构将系统中主要的元数据管理工作由OSD来完成，降低了Client的开销。
& && && &3.3、元数据服务器（Metadata Server，MDS）
& && && & MDS控制Client与OSD对象的交互，主要提供以下几个功能：
& && &（1） 对象存储访问。& && &&&MDS构造、管理描述每个文件分布的视图，允许Client直接访问对象。MDS为Client提供访问该文件所含对象的能力，OSD在接收到每个请求时将先验证该能力，然后才可以访问。& && &（2） 文件和目录访问管理。& && &&&MDS在存储系统上构建一个文件结构，包括限额控制、目录和文件的创建和删除、访问控制等。& &&&（3） Client Cache一致性。& && &&&为了提高Client性能，在对象存储系统设计时通常支持Client方的Cache。由于引入Client方的Cache，带来了Cache一致性问题，MDS支持基于Client的文件Cache，当Cache的文件发生改变时，将通知Client刷新Cache，从而防止Cache不一致引发的问题。
& && & 3.4、对象存储系统的客户端Client
& && &&&为了有效支持Client支持访问OSD上的对象，需要在计算节点实现对象存储系统的Client，通常提供POSIX文件系统接口，允许应用程序像执行标准的文件系统操作一样。
TA的最新馆藏
喜欢该文的人也喜欢查看: 69796|回复: 6
openstack入门之swift基础二：三种存储类型比较-文件、块、对象存储
主题帖子积分
本帖最后由 pig2 于
15:11 编辑
上一篇我们讲了，这里我们进一步了解
我们知道swift是对象存储，那么什么是对象存储，对象存储和其它存储有什么区别。
我们可以带着下面问题来阅读：
1.说一下对象存储结构组成部分？
2.对象存储系统中数据存储的基本单位是什么？
3.对象是文件的数据和一组属性信息的组合，这些属性信息如何定义？
4.对象存储设备为什么具有一定的智能？
欢迎加入about云群 、 ，云计算爱好者群，关注
主题帖子积分
本帖最后由 pig2 于
18:51 编辑
1.块存储包含几种存储方式
块存储和文件存储是我们比较熟悉的两种主流的存储类型，而对象存储（Object-based Storage）是一种新的网络存储架构，基于对象存储技术的设备就是对象存储设备（Object-based Storage Device）简称OSD。
& && &&&首先，我们介绍这两种传统的存储类型。通常来讲，所有磁盘阵列都是基于Block块的模式，而所有的NAS产品都是文件级存储。
& && &&&以下列出的两种存储方式都是块存储类型：
& && &&&1） DAS（Direct Attach STorage）：是直接连接于主机服务器的一种储存方式，每一台主机服务器有独立的储存设备，每台主机服务器的储存设备无法互通，需要跨主机存取资料时，必须经过相对复杂的设定，若主机服务器分属不同的操作系统，要存取彼此的资料，更是复杂，有些系统甚至不能存取。通常用在单一网络环境下且数据交换量不大，性能要求不高的环境下，可以说是一种应用较为早的技术实现。
& && &&&2）SAN（Storage Area Network）：是一种用高速（光纤）网络联接专业主机服务器的一种储存方式，此系统会位于主机群的后端，它使用高速I/O 联结方式， 如 SCSI, ESCON 及 Fibre- Channels。一般而言，SAN应用在对网络速度要求高、对数据的可靠性和安全性要求高、对数据共享的性能要求高的应用环境中，特点是代价高，性能好。例如电信、银行的大数据量关键应用。它采用SCSI 块I/O的命令集，通过在磁盘或FC（Fiber Channel）级的数据访问提供高性能的随机I/O和数据吞吐率，它具有高带宽、低延迟的优势，在高性能计算中占有一席之地，但是由于SAN系统的价格较高，且可扩展性较差，已不能满足成千上万个CPU规模的系统。
2、文件存储
& && &&&通常，NAS产品都是文件级存储。&&NAS（Network Attached Storage）：是一套网络储存设备，通常是直接连在网络上并提供资料存取服务，一套 NAS 储存设备就如同一个提供数据文件服务的系统，特点是性价比高。例如教育、政府、企业等数据存储应用。
& && &&&它采用NFS或CIFS命令集访问数据，以文件为传输协议，通过TCP/IP实现网络化存储，可扩展性好、价格便宜、用户易管理，如目前在集群计算中应用较多的NFS文件系统，但由于NAS的协议开销高、带宽低、延迟大，不利于在高性能集群中应用。
& &&&下面，我们对DAS、NAS、SAN三种技术进行比较和分析：
表格 1 三种技术的比较
1.jpg (78.33 KB, 下载次数: 14)
14:27 上传
2.jpg (49.59 KB, 下载次数: 4)
14:27 上传
针对Linux集群对存储系统高性能和数据共享的需求，国际上已开始研究全新的存储架构和新型文件系统，希望能有效结合SAN和NAS系统的优点，支持直接访问磁盘以提高性能，通过共享的文件和元数据以简化管理，目前对象存储系统已成为Linux集群系统高性能存储系统的研究热点，如Panasas公司的Object Base Storage Cluster System系统和Cluster File Systems公司的Lustre等。下面将详细介绍对象存储系统。
3、对象存储
& && &&&总体上来讲，对象存储同兼具SAN高速直接访问磁盘特点及NAS的分布式共享特点。
& && &&&核心是将数据通路（数据读或写）和控制通路（元数据）分离，并且基于对象存储设备（Object-based Storage Device，OSD）构建存储系统，每个对象存储设备具有一定的智能，能够自动管理其上的数据分布。
& && &&&对象存储结构组成部分（对象、对象存储设备、元数据服务器、对象存储系统的客户端）：
& && &&&3.1、对象
& && &&&对象是系统中数据存储的基本单位，一个对象实际上就是文件的数据和一组属性信息（Meta Data）的组合，这些属性信息可以定义基于文件的RAID参数、数据分布和服务质量等，而传统的存储系统中用文件或块作为基本的存储单位，在块存储系统中还需要始终追踪系统中每个块的属性，对象通过与存储系统通信维护自己的属性。在存储设备中，所有对象都有一个对象标识，通过对象标识OSD命令访问该对象。通常有多种类型的对象，存储设备上的根对象标识存储设备和该设备的各种属性，组对象是存储设备上共享资源管理策略的对象集合等。
& && & 3.2、对象存储设备
& && &&&对象存储设备具有一定的智能，它有自己的CPU、内存、网络和磁盘系统，OSD同块设备的不同不在于存储介质，而在于两者提供的访问接口。OSD的主要功能包括数据存储和安全访问。目前国际上通常采用刀片式结构实现对象存储设备。OSD提供三个主要功能：
& && &（1） 数据存储。OSD管理对象数据，并将它们放置在标准的磁盘系统上，OSD不提供块接口访问方式，Client请求数据时用对象ID、偏移进行数据读写。& && &（2） 智能分布。OSD用其自身的CPU和内存优化数据分布，并支持数据的预取。由于OSD可以智能地支持对象的预取，从而可以优化磁盘的性能。& && &（3） 每个对象元数据的管理。OSD管理存储在其上对象的元数据，该元数据与传统的inode元数据相似，通常包括对象的数据块和对象的长度。而在传统的NAS系统中，这些元数据是由文件服务器维护的，对象存储架构将系统中主要的元数据管理工作由OSD来完成，降低了Client的开销。
& && && &3.3、元数据服务器（Metadata Server，MDS）
& && && & MDS控制Client与OSD对象的交互，主要提供以下几个功能：
& && &（1） 对象存储访问。& && &&&MDS构造、管理描述每个文件分布的视图，允许Client直接访问对象。MDS为Client提供访问该文件所含对象的能力，OSD在接收到每个请求时将先验证该能力，然后才可以访问。& && &（2） 文件和目录访问管理。& && &&&MDS在存储系统上构建一个文件结构，包括限额控制、目录和文件的创建和删除、访问控制等。& &&&（3） Client Cache一致性。& && &&&为了提高Client性能，在对象存储系统设计时通常支持Client方的Cache。由于引入Client方的Cache，带来了Cache一致性问题，MDS支持基于Client的文件Cache，当Cache的文件发生改变时，将通知Client刷新Cache，从而防止Cache不一致引发的问题。
& && & 3.4、对象存储系统的客户端Client
& && &&&为了有效支持Client支持访问OSD上的对象，需要在计算节点实现对象存储系统的Client，通常提供POSIX文件系统接口，允许应用程序像执行标准的文件系统操作一样。
欢迎加入about云群 、 ，云计算爱好者群，关注
主题帖子积分
中级会员, 积分 925, 距离下一级还需 75 积分
中级会员, 积分 925, 距离下一级还需 75 积分
好东西&&光看视频是不行的，还得多了解底层知识点&&
主题帖子积分
注册会员, 积分 138, 距离下一级还需 62 积分
注册会员, 积分 138, 距离下一级还需 62 积分
不错。分析的透彻。
主题帖子积分
注册会员, 积分 138, 距离下一级还需 62 积分
注册会员, 积分 138, 距离下一级还需 62 积分
看完能够加深三种存储架构的认识。
主题帖子积分
新手上路, 积分 5, 距离下一级还需 45 积分
新手上路, 积分 5, 距离下一级还需 45 积分
1.块存储包含几种存储方式
块存储和文件存储是我们比较熟悉的两种主流的存储类型，而对象存储（Object-b ...
最近在了解对象存储的知识，这篇帖子介绍的和Luster里面的对象存储是一样的
可是swift里面不是没有元数据这一说法么？Swift里面也没有元数据服务器和基于对象的存储设备，swift的面向对象究竟和Luster有什么区别？
主题帖子积分
高级会员, 积分 1281, 距离下一级还需 3719 积分
高级会员, 积分 1281, 距离下一级还需 3719 积分
最近在了解对象存储的知识，这篇帖子介绍的和Luster里面的对象存储是一样的
可是swift里面不是没有元数 ...
你们用Luster了？你说说你们的Luster是什么
欢迎加入about云群、，云计算爱好者群
经常参与各类话题的讨论，发帖内容较有主见
经常帮助其他会员答疑
活跃且尽责职守的版主
为论坛做出突出贡献的会员
站长推荐 /4
云计算hadoop视频大全(新增 yarn、flume|storm、hadoop一套视频
等待验证会员请验证邮箱
新手获取积分方法
技术类问答，解决学习openstack，hadoop生态系统中遇到的问题
Powered by在Swift中定义属于自己的运算符 - 简书
在Swift中定义属于自己的运算符
Hello 各位，今天我来讲一讲怎么样在Swift工程中定义属于自己的运算符。起初有这个想法是因为Swift存在可选类型，比如：
var foo: String?
//定义这个样一个类型，在没有赋值的情况下使用它
let bar = foo!
//这样绝对会崩溃，因为它是`nil`啊，强制解包绝对傻了。所以我定义了运算符，省的判断：
let bar = foo~~
//这样，如果它是空，就返回`""`（空字符串）
666有没有，主要是懒……
好吧我们进入正题：
Xcode有一个东西叫做playground：
图片大小：23KB
所以我们新建一个playground，在这里随便玩耍：
图片大小：54KB
(别嫌弃我代码配色丑。。)
我们把import UIKit和var str = "Hello, playground"删掉。然后写下来一行代码:
postfix operator ~~{}
代码中的~~是你自定义的运算符，这个运算符最好不要和系统的重复了，如果重复了你要小心。。我们声明了运算符~~，但是系统不知道这个运算符应该干什么呀，所以还需要下面的代码：
postfix func ~~(
v: String?
) -& String {
return v == nil ? "" : v!
只是一个简单的双目运算符，如果传入的值是一个可选的String类型，如果他是空，就返回一个空字符串，如果不是空，就返回他解包后的值。
我们来使用一下：
图片大小：6KB
啊！对了，在playground中右侧可以实时看到变量值，具体大家慢慢摸索就知道很好玩了。
可以看出来，变量foo的值是：nil，常量bar的值是：""
图片大小：可以无视
接下来重载这个函数，把能想到的能用到的类型全搞上去！！
postfix operator ~~ {}
postfix func ~~(a: String?)
{ return a == nil ? "" : a! }
postfix func ~~(a: Int?)
{ return a == nil ? 0 : a! }
postfix func ~~(a: Int8?)
{ return a == nil ? 0 : a!}
postfix func ~~(a: Int16?)
{ return a == nil ? 0 : a! }
postfix func ~~(a: Int32?)
{ return a == nil ? 0 : a! }
postfix func ~~(a: Int64?)
{ return a == nil ? 0 : a! }
postfix func ~~(a: UInt?)
{ return a == nil ? 0 : a! }
postfix func ~~(a: Double?)
{ return a == nil ? 0 : a! }
postfix func ~~(a: Float?)
{ return a == nil ? 0 : a! }
postfix func ~~(a: [AnyObject]?)
-& [AnyObject]
{ return a == nil ? [] : a! }
postfix func ~~(a: [String]?)
-& [String]
{ return a == nil ? [] : a! }
postfix func ~~(a: [Int]?)
{ return a == nil ? [] : a! }
postfix func ~~(a: [String: AnyObject]?) -& [String: AnyObject] { return a == nil ? [:] : a! }
postfix func ~~(a: [String: String]?)
-& [String: String]
{ return a == nil ? [:] : a! }
然后就随便用了，再也不怕出现空值还需要单独判断了。。。
但是大家想一下，运算符都是放在右边的吗？
图片大小：6KB
当然不是：var a = 0中的=运算符是中置运算符a += 1中的+=同样是中置a = a++中的++运算符是右置a = --a中的--运算符是左置
那怎么定义一个运算符在左边还是右边起作用？
重点在这：
postfix operator ~~{}
我们这个声明有一个修饰：postfix，就是他！
左：prefix
右：postfix
下面奉上Swift中一些运算符的声明：
infix operator += {
associativity right //结合性，右结合
precedence 90
//优先级，90
infix operator * {
associativity left
precedence 150
infix operator - {
associativity left
precedence 140
infix operator + {
associativity left
precedence 140
忘了说了！Swift 2.2中废弃了 ++、--这种运算符，改为+= 1、-= 1
associativity(结合性)：
precedence(优先级)：
0～255 可选范围
好了，就到这里，前面说不要和系统运算符重复是怕不小心重载了某个运算符，比如这种效果。。
图片大小：273KB
那么问题来了，1+1在什么情况下会等于3！哈哈哈哈。。。
我去吃药了。。。
iLakeYC感谢您的阅读
下面奉上Swift标准库的实验接口。来自SwiftExperimental.swift
//===----------------------------------------------------------------------===//
// Experimental APIs of the Swift Standard Library
// This library contains experimental APIs that can be subject to change or
// removal.
We don't guarantee API or ABI stability for this library.
//===----------------------------------------------------------------------===//
import Swift
/// The function composition operator is the only user-defined operator that
/// operates on functions.
That's why the numeric value of precedence does
/// not matter right now.
infix operator ? {
// The character is U+2218 RING OPERATOR.
// Confusables:
// U+00B0 DEGREE SIGN
// U+02DA RING ABOVE
// U+25CB WHITE CIRCLE
// U+25E6 WHITE BULLET
associativity left
precedence 100
/// Compose functions.
(g ? f)(x) == g(f(x))
/// - Returns: a function that applies ``g`` to the result of applying ``f``
to the argument of the new function.
public func ?&T, U, V&(g: U -& V, f: T -& U) -& (T -& V) {
return { g(f($0)) }
infix operator \ { associativity left precedence 140 }
infix operator \= { associativity right precedence 90 assignment }
infix operator ∪ { associativity left precedence 140 }
infix operator ∪= { associativity right precedence 90 assignment }
infix operator ∩ { associativity left precedence 150 }
infix operator ∩= { associativity right precedence 90 assignment }
infix operator ? { associativity left precedence 140 }
infix operator ?= { associativity right precedence 90 assignment }
infix operator ∈ { associativity left precedence 130 }
infix operator ? { associativity left precedence 130 }
infix operator ? { associativity left precedence 130 }
infix operator ? { associativity left precedence 130 }
infix operator ? { associativity left precedence 130 }
infix operator ? { associativity left precedence 130 }
infix operator ? { associativity left precedence 130 }
infix operator ? { associativity left precedence 130 }
infix operator ? { associativity left precedence 130 }
infix operator ? { associativity left precedence 130 }
/// - Returns: The relative complement of `lhs` with respect to `rhs`.
public func \ &
T, S: Sequence where S.Iterator.Element == T
&(lhs: Set&T&, rhs: S) -& Set&T& {
return lhs.subtract(rhs)
/// Assigns the relative complement between `lhs` and `rhs` to `lhs`.
public func \= &
T, S: Sequence where S.Iterator.Element == T
&(lhs: inout Set&T&, rhs: S) {
lhs.subtractInPlace(rhs)
/// - Returns: The union of `lhs` and `rhs`.
public func ∪ &
T, S: Sequence where S.Iterator.Element == T
&(lhs: Set&T&, rhs: S) -& Set&T& {
return lhs.union(rhs)
/// Assigns the union of `lhs` and `rhs` to `lhs`.
public func ∪= &
T, S: Sequence where S.Iterator.Element == T
&(lhs: inout Set&T&, rhs: S) {
lhs.unionInPlace(rhs)
/// - Returns: The intersection of `lhs` and `rhs`.
public func ∩ &
T, S: Sequence where S.Iterator.Element == T
&(lhs: Set&T&, rhs: S) -& Set&T& {
return lhs.intersect(rhs)
/// Assigns the intersection of `lhs` and `rhs` to `lhs`.
public func ∩= &
T, S: Sequence where S.Iterator.Element == T
&(lhs: inout Set&T&, rhs: S) {
lhs.intersectInPlace(rhs)
/// - Returns: A set with elements in `lhs` or `rhs` but not in both.
public func ? &
T, S: Sequence where S.Iterator.Element == T
&(lhs: Set&T&, rhs: S) -& Set&T& {
return lhs.exclusiveOr(rhs)
/// Assigns to `lhs` the set with elements in `lhs` or `rhs` but not in both.
public func ?= &
T, S: Sequence where S.Iterator.Element == T
&(lhs: inout Set&T&, rhs: S) {
lhs.exclusiveOrInPlace(rhs)
/// - Returns: True if `x` is in the set.
public func ∈ &T&(x: T, rhs: Set&T&) -& Bool {
return rhs.contains(x)
/// - Returns: True if `x` is not in the set.
public func ? &T&(x: T, rhs: Set&T&) -& Bool {
return !rhs.contains(x)
/// - Returns: True if `lhs` is a strict subset of `rhs`.
public func ? &
T, S: Sequence where S.Iterator.Element == T
&(lhs: Set&T&, rhs: S) -& Bool {
return lhs.isStrictSubsetOf(rhs)
/// - Returns: True if `lhs` is not a strict subset of `rhs`.
public func ? &
T, S: Sequence where S.Iterator.Element == T
&(lhs: Set&T&, rhs: S) -& Bool {
return !lhs.isStrictSubsetOf(rhs)
/// - Returns: True if `lhs` is a subset of `rhs`.
public func ? &
T, S: Sequence where S.Iterator.Element == T
&(lhs: Set&T&, rhs: S) -& Bool {
return lhs.isSubsetOf(rhs)
/// - Returns: True if `lhs` is not a subset of `rhs`.
public func ? &
T, S: Sequence where S.Iterator.Element == T
&(lhs: Set&T&, rhs: S) -& Bool {
return !lhs.isSubsetOf(rhs)
/// - Returns: True if `lhs` is a strict superset of `rhs`.
public func ? &
T, S: Sequence where S.Iterator.Element == T
&(lhs: Set&T&, rhs: S) -& Bool {
return lhs.isStrictSupersetOf(rhs)
/// - Returns: True if `lhs` is not a strict superset of `rhs`.
public func ? &
T, S: Sequence where S.Iterator.Element == T
&(lhs: Set&T&, rhs: S) -& Bool {
return !lhs.isStrictSupersetOf(rhs)
/// - Returns: True if `lhs` is a superset of `rhs`.
public func ? &
T, S: Sequence where S.Iterator.Element == T
&(lhs: Set&T&, rhs: S) -& Bool {
return lhs.isSupersetOf(rhs)
/// - Returns: True if `lhs` is not a superset of `rhs`.
public func ? &
T, S: Sequence where S.Iterator.Element == T
&(lhs: Set&T&, rhs: S) -& Bool {
return !lhs.isSupersetOf(rhs)
不只是个程序猿}