Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
Uses the NaturalLanguage framework combined with a thesaurus API to replace adjectives in a sentence with synonyms. This is designed to be run in a Swift Playground.
import UIKit
import NaturalLanguage
import PlaygroundSupport
//: Your secret API key from `https://dictionaryapi.com` goes here.
//: THIS WON'T WORK UNLESS YOU GET A KEY.
let thesaurusKey = ""
//: The string you want to work on.
var testString = "The bright sun set behind the green hills. Thin clouds streaked the red sky."
//: Since we are making an API request as part of this playground, we need to allow it time to finish.
PlaygroundPage.current.needsIndefiniteExecution = true
/// The API returns an array of this data type. We're going to ignore everything except the synonyms.
struct ThesaurusResponse: Decodable {
struct Metadata: Decodable {
/// An array of synonym arrays. Each array is related to a different homograph of the query. Picking the right
/// one by context will require a deeper analysis of the API response.
let synonyms: [[String]]
enum CodingKeys: String, CodingKey {
case synonyms = "syns"
}
}
/// The top-level wrapper for metadata.
let meta: Metadata
}
/// Keep track of where in the string the word is we're going to replace so that we can do efficient string replacement.
/// Also, this will prevent all homographs identical to the query from being replaced simultaneously.
struct ReplacementTarget {
let value: String
let range: Range<String.Index>
}
/// Create a URLRequest for the dictionary API.
///
/// - Parameter query: The string which we are requesting synonyms for.
/// - Returns: A URLRequest that can be executed to query the API.
///
func createRequest(for query: String) -> URLRequest {
guard let escapedQuery = query.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed) else {
fatalError("The query '\(query)' could not be requested.")
}
var urlComps = URLComponents(string: "https://www.dictionaryapi.com/api/v3/references/thesaurus/json/\(escapedQuery)")!
urlComps.queryItems = [URLQueryItem(name: "key", value: thesaurusKey)]
var urlRequest = URLRequest(url: urlComps.url!)
urlRequest.httpMethod = "GET"
return urlRequest
}
/// Requet sender using default configuration.
let session = URLSession(configuration: .default)
/// Response JSON parser.
let decoder = JSONDecoder()
print("Tagging the string: \(testString)")
//: We want to examine the entire string.
let stringRange = testString.startIndex..<testString.endIndex
//: Create and set up the NLTagger instance that will categorize the words. We are only interested in the words,
//: not the punctuation or white spaces.
let tagger = NLTagger(tagSchemes: [.nameTypeOrLexicalClass])
tagger.string = testString
let allTags = tagger.tags(
in: stringRange,
unit: .word,
scheme: .nameTypeOrLexicalClass,
options: [.omitWhitespace, .omitPunctuation]
)
//: Filter the tags to find only the adjectives.
let adjectives = allTags.compactMap { (tag, range) -> ReplacementTarget? in
guard
let tag = tag,
tag == .adjective
else { return nil }
return ReplacementTarget(value: String(testString[range]), range: range)
}
print("Found \(adjectives.count) adjective(s): \(adjectives.map{ $0.value }.joined(separator: ", "))")
//: Pick a random adjective to send to the API for synonyms.
guard let selectedTarget = adjectives.randomElement() else {
fatalError("No adjectives found in string.")
}
//: Construct and send the URLRequest.
let query = selectedTarget.value
print("Executing API request for '\(query)'.")
let request = createRequest(for: query)
let task = session.dataTask(with: request) { (data, response, error) in
//: Whether the response is a success or failure, we want playground execution to finish once we're done here.
defer { PlaygroundPage.current.finishExecution() }
//: Ensure we received a response and not an error.
guard let data = data else {
if let error = error {
print("ERROR: \(error.localizedDescription)")
} else {
print("ERROR: Query failed for an unknown reason.")
}
return
}
//: Attempt to decode the response.
do {
let response = try decoder.decode([ThesaurusResponse].self, from: data)
guard
let synonyms = response.first?.meta.synonyms.first,
!synonyms.isEmpty
else {
print("No synonyms returned from the API.")
return
}
//: Until such time as we do extra work to at least ensure that we are picking the correct part-of-speech
//: ("light" as a verb or a noun, for instance), we're just picking the first synonym set and picking a
//: random replacement.
print("Found \(synonyms.count) synonyms: \(synonyms.joined(separator: ", "))")
guard let substitution = synonyms.randomElement() else {
fatalError("Unable to pick a substitution.")
}
print("Picked '\(substitution)' as a substitution.")
let modifiedString = testString.replacingCharacters(in: selectedTarget.range, with: substitution)
print("Modified string: \(modifiedString)")
} catch {
print("Failed to decode the API response: \(error.localizedDescription)")
print("\(String(data: data, encoding: .utf8)!)")
}
}
//: Send the request to the API.
task.resume()
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment