13hoop

//
//  HyperlinkLabel.swift
//  SLHome
//
//  Created by yongren on 2022/1/6.
//

import Foundation

/// A UILabel subclass that responds to links tap.

13hoop

class Server {
    private init() {}
    static let shared = Server.init()
    private static let serverQueue = DispatchQueue.global(qos: .background)
    func getCountries(completion: @escaping (Array<String>) -> Void) {
        let countries = ["France", "Germany", "Spain", "Portugal"]
        let delay = Int.random(in: 1..<4)
        Self.serverQueue.asyncAfter(deadline: .now() + .seconds(delay)) {
            completion(countries)
        }

13hoop

libdispatch efficiency tips

I suspect most developers are using the libdispatch inefficiently due to the way it was presented to us at the time it was introduced and for many years after that, and due to the confusing documentation and API. I realized this after reading the 'concurrency' discussion on the swift-evolution mailing-list, in particular the messages from Pierre Habouzit (who is the libdispatch maintainer at Apple) are quite enlightening (and you can also find many tweets from him on the subject).

• https://lists.swift.org/pipermail/swift-evolution/Week-of-Mon-20170828/date.html
• https://lists.swift.org/pipermail/swift-evolution/Week-of-Mon-20170904/date.html
• https://twitter.com/pedantcoder

My take-aways are:

13hoop

/**--------  swift 集合类型解读 之 Collection - 1213/17

    通过定一个 队列 来熟悉 Collection协议
 其区别于 栈 ，栈的实现可以通过数组Array实现，但其会在练习内存中持有元素，这对 pop & push 来说很简单，但一旦有 remove(at: ) 这样的操作，时间复杂就会是 O(n)
 */

protocol YRQueen {
    associatedtype Element
    // 入队
    mutating func enQueen(_ newElement: Element)

13hoop

package net.jmecn.math;

/**
 * 四元数
 * 
 *
 */
public class Quaternion {

    public float x, y, z, w;

13hoop

//--------  swift 集合类型解读 之 Sequence - 1212
/*
    另一个 完备的模拟使用，比如在 终端上的打印所有的输入过程
 */
// a 实现一个 Iterator
struct PrefixIterator: IteratorProtocol {
    let str: String
    var offset: String.Index
    

13hoop

//--------  swift 集合类型解读 - 1210
/*
  --> Sequence 协议
    这个协议是内置集合类型的核心，正是它让 针对元素序列的通用操作 成为可能
    其规定了要实现跟返回一个 迭代器（Iterator）
    protocol Sequence {
        associatedtype Iterator: IteratorProtocol // 这里使用了 关联类型，作用就是协议中的 “范型” 或者 “alias”
        func makeIterator() -> Iterator
    }
    --> IteratorProtocol 协议，一般只有在自定义序列类型的时候才使用

13hoop

protocol SoundsFunc {
    func voice () -> String
}

class Computer {
    var name: String
    init(name: String) {
        self.name = name;
    }
    func calculat() {

13hoop

import Foundation

protocol Channel: IteratorProtocol {
    func send(_ value: Element?)
}

/// A blocking channel for sending values.
///
/// `send` and `receive` must run in separate separate execution contexts, otherwise you get a deadlock.
final class BlockingChannel<A>: Channel {

13hoop

export function currentUser() {
  let user = AV.User.current()
  if (user) {
    // let r = parseUserFromAVUser(user)
    // console.log( '-- user --: ' + r['objectId'])
    return parseUserFromAVUser(user)
  } else {
    return undefined
  }
}