Sajjon

struct ScanJob {
    let runContext: RunContext
}

// MARK: Job
extension ScanJob: CacheableJob {

    typealias Input = RunContext
    typealias Output = ScannedLines

Sajjon

protocol CacheableJob: Job where Output: Codable {
    var runContext: RunContext { get }
    var fileName: String { get }
    func newWork(input: Input) throws -> Output
    func validateCached(_ cached: Output) throws
}

struct CachedJob<CachedData>: Codable where CachedData: Codable {
    let fileNameOfInputCorpus: String

Sajjon

func createWordList() throws {

    let pipeline = Pipeline {
        ScanJob()
        ParseJob()
        WordLengthJob()
        WhitelistedPOSTagsJob()
        HomonymJob()
    }

Sajjon

// MARK: FunctionBuilder
@_functionBuilder
struct BuildPipeline {

    static func buildBlock<A>(_ a: A) -> Pipeline<A.Input, A.Output>
        where
        A: Job
    {
        Pipeline(description: descriptionOf(jobs: [a])) { input in

Sajjon

struct Pipeline<Input, Output>: Job, CustomStringConvertible {
    let description: String
    private let _getOutput: (Input) throws -> Output
    
  init(description: String, _ getOutput: @escaping (Input) throws -> Output) {
        self.description = description
        self._getOutput = getOutput
    }
}

Sajjon

precedencegroup Pipe {
    higherThan: DefaultPrecedence
    associativity: left
    assignment: true
}

infix operator |>: Pipe
func |> <J>(input: J.Input, job: J) throws -> J.Output where J: Job {
    try job.work(input: input)
}

Sajjon

protocol Job {
    associatedtype Input
    associatedtype Output
    func work(input: Input) throws -> Output
}

Sajjon

protocol LineFromCorpusConvertible: CustomStringConvertible, Codable {
    /// The word, on lowercased form
    var wordForm: WordForm { get }

    /// Part of speech tag, only first major tag, .e.g from line `han    PN.UTR.SIN.DEF.SUB`, we only save `PN`
    var partOfSpeechTag: PartOfSpeech { get }

    /// Base form(s) of word
    var lemgrams: Lemgrams { get }

Sajjon

/// A line which word has suitable length
struct WordLengthLine: LineFromCorpusFromLine, Hashable {
    typealias FromLine = ParsedLine
    let line: FromLine
}

Sajjon

/// A parsed line from some scanned line in the corpus.
struct ParsedLine: Codable, Hashable {

    let wordForm: WordForm
    let partOfSpeechTag: PartOfSpeech
    let lemgrams: Lemgrams
    let isCompoundWord: Bool
    let numberOfOccurencesInCorpus: Int
    let relativeFrequencyPerOneMillion: Int