Swift Syntax and Structured Editing Library (github.com)

There’s some really interesting work coming out of the Swift project and smart people involved in it’s development but I keep feeling like not enough attention is being paid to basics. Tooling and compiler performance need some serious attention. These are boring tasks but crucial for the language’s wider appeal.

Exciting stuff.

With async/await landing last week and the leaps and bounds of the package manager over the last couple years, the ergonomics of using Swift for non-iOS work has gotten significantly better. Coupled with the built in safety and elegance of the language I think that, especially for server work, Swift is a very attractive option.

Shameless plug; for these reasons I built a Swift backend framework for fullstack iOS development[1] that we've been using it at my company while going through YC this summer.

It's been very powerful to have mobile and server in the same language and codebase and has helped us (native iOS backgrounds), move quickly.

1: https://github.com/alchemy-swift/alchemy

  final class Planet: Model {
      // Name of the table or collection.
      static let schema = "planets"

      // Unique identifier for this Planet.
      @ID(key: .id)
      var id: UUID?

      // The Planet's name.
      @Field(key: "name")
      var name: String

      // Creates a new, empty Planet.
      init() { }

      // Creates a new Planet with all properties set.
      init(id: UUID? = nil, name: String) {
          self.id = id
          self.name = name
      }
  }

  struct Planet: Model {
      var id: UUID?
      var name: String
  }

  final class Star: Model {
      @Children(for: \.$star) // 1-M
      var planets: [Planet]

      @Parent(key: "star_id") // M-1
      var star: Star
  }

  struct Star: Model {
      @BelongsTo var star: Star // M-1
      @HasMany var planets: [Planet] // 1-M
      @HasMany var moons: [Moon] // “Has Many Through”

      static func mapRelations(_ mapper: RelationshipMapper<User>) {
          // infers mapping from stars.id -> plants.star_id -> planets.id -> moons.planet_id
          mapper.config(\.$moons).through(“planets”)
      }
  }

"If it represents authored Swift source, then the data representing it is immutable. You don't change what an author wrote without their permission and initiation."

I'm sorry, what ?? Did i read this correctly ? Are they representing code using either mutable or immutable structures depending on whether the sourcecode has copyright or not ?

I'm really confused...

I want to take the chance while Swift is on the front-page to talk about something mind-blowingly exciting (to me, at least) about it that people might not be aware of:

  >> Swift has support for C++ interop, without writing manual bindings! <<

Yes, you read that right. Swift can interop with and import C++ members/values, without needing to write a corresponding Swift type mapping. It's currently the only language I'm aware of that can do this (Nim doesn't count). I think it's because Swift is so integrated into LLVM/clang, that it can do a sort of mixed-compilation of Swift/CXX sources. Such that from a compiler's perspective which language they come from doesn't matter -- but I have no real clue.

It's very early, but it can already do some impressive things. The "cxx-interop" tag on the Swift Forums will show you what is basically a timeline of it's development and current status:

  https://forums.swift.org/tag/cxx-interop

And here is the "C++ Interopability Manifesto", the outline they have for the feature in the language:

  https://github.com/apple/swift/blob/main/docs/CppInteroperabilityManifesto.md

For a real-world example of using this, here's a test repo from the core developers:

  https://github.com/plotfi/cxx-interop-test
  https://github.com/plotfi/cxx-interop-test/blob/main/Sources/CXX/include/CXX.h
  https://github.com/plotfi/cxx-interop-test/blob/main/Sources/Swift/main.swift

You see here direct import and use of "std::" namespace, including "std::vector" and "std::string_view", as well as use of structs and arrays:

    import CXX // <-- This is CXX.h, local C++ file
    import std.string_view
    import std.vector

    "42".withCString { cstring in
        let view = std.__1.string_view(cstring)
        assert(is_str_42(view))
    }

    var MS = MyStruct()
    var MS1 = MS[0]

    var v = V()
    let arr = v.getVec()[0].swift_array()
    print("std::vector: \(arr)")

Fucking mindblowing! It requires a ".modulemap" for the C++ code, but that can be auto-generated with most build tools AFAIK.

This is one of the most exciting things happening in tech for me. With Swift supporting Windows now, you have a great language for consuming C/C++ libraries and publishing native binaries or shared libs. Really looking forward to the future developments here.

I have never even written Swift, but I've been following the developments here closely. After Swift 5.5 features, looking like a really solid language if you want to do systems programming but can sacrifice some binary size and performance for a higher level language. Particularly the new Actors stuff for safe concurrency.

(Also, there's a chance Kotlin Native may get C++ support in the future, which would also be sweet)

This might be a foolish question — but why not write this in Swift?

> # Ignore the following admonition; it applies to the resulting .cpp file only

I wonder why the tool doesn't insert the admonition automatically? Then it would never get forgetten, and no disclaimer would be necessary in the actual source.

I've also found a time/date stamp to come in handy more than once.

I'm not sure I understand the significance of this library.

Can it help implement something like a Visual Studio Code Language Server?

    functions
      .where(params.last.isClosure)
      .where(returnType: Void.self)
      .forEach { f in
        f.setReturnType(f.params.last?.asClosure.paramsTuple)
        f.setAsync(true)
        f.setThrows()
      }