I get this error when trying to compile on OSX with the latest swift 2.2 dec 31 snapshot.

Compiling Swift Module 'SwiftFoundation' (51 sources) /SwiftFoundationExample/Packages/SwiftFoundation-1.1.0/Sources/SwiftFoundation/POSIXFileSystemStatus.swift:28:45: error: thrown expression type 'POSIXError' does not conform to 'ErrorType' throw POSIXError.fromErrorNumber!

I'm looking for a good foundation-free JSON serializer and came upon PureSwift's, which has the barebones - exactly what I need. However, including the entire SwiftFoundation project is overkill if I just want JSON.

I propose to split all the large sections into separate repositories, and then this repository would just be the core that links them together and conforms the types to the necessary (probably FoundationConvertible) protocols. This might be a pain to do right now, but in the long run it's a much better solution.

For base64 tests you might want to include the ones here in addition to the tests you already have: https://github.com/drichardson/SwiftyBase64/blob/master/SwiftyBase64Tests/SwiftyBase64Tests.swift since they specifically cover different cases the base64 encoder has to handle (thanks for the header attribution, btw).

Also, I think an open source, cross platform, pure swift replacement for Foundation is a great idea.

Hey,

this is not really an issue but more a feature. I want to implement a cross platform (macos, iOS, Windows, Linux) tool and need some JSON de-serialization and file management. Currently I think about which library I want to use. My main question is if it is generally possible to compile Swift foundation under Windows since the OS is not listed in your readme.

Previous example code (e.g., in the RegularExpressionTests) relied on NSString and NSRange to obtain the matching string or the captured groups.

For example:

let stringRange = NSRange(match.range)

let matchString = (string as NSString).substringWithRange(stringRange)

With this code, it can be shortened, with a pure Swift implementation:

let matchString = string.substring(match.range)

Also added a test case for emoji support in RegularExpression that uses these methods.

This convenience initializer take milliseconds as Long instead of a Double value of seconds. This is similar to the Date class in Javascript, and is useful for many JSON APIs that use number of milliseconds since epoch to represent dates.

Further I think the word TimeInterval should be renamed to Seconds in the API of the Date object to be less vague.

On 713b3ce:

First, not found CUUID.

SwiftFoundation/Sources/SwiftFoundation/UUID.swift:14:12: error: no such module 'CUUID'
    import CUUID
           ^

Edited Package.swift fixing the above error:

--- a/Package.swift
+++ b/Package.swift
@@ -11,7 +11,8 @@ let package = Package(
     ],
     dependencies: [
         .Package(url: "https://github.com/PureSwift/CStatfs.git", majorVersion: 1),
-        .Package(url: "https://github.com/PureSwift/CJSONC.git", majorVersion: 1)
+        .Package(url: "https://github.com/PureSwift/CJSONC.git", majorVersion: 1),
+        .Package(url: "https://github.com/PureSwift/CUUID.git", majorVersion: 1)
     ],
     exclude: ["Xcode", "Carthage"]
 )

Then failed to compile SwiftFoundation/Thread.swift:

`` src/SwiftFoundation/Sources/SwiftFoundation/Thread.swift:30:54: error: va$ ue of type 'Unmanaged<Thread.Closure>' has no member 'toOpaque' let pointer = UnsafeMutablePointer(holder.toOpaque()) ^~~~~~ ~~~~~~~~ src/SwiftFoundation/Sources/SwiftFoundation/Thread.swift:89:65: error: ca$ not convert value of type 'UnsafeMutablePointer' (aka 'UnsafeMutablePoint$ r<()>') to expected argument type 'OpaquePointer' let unmanaged = Unmanaged<Thread.Closure>.fromOpaque(arg!) ~~~^

Hey man! I really liked this. I saw you forked my HTTP Server / Web Framework. Really enjoying this pure swift experiment. I see you have done a lot of similar work like, regular expressions, base64, etc.. This is really cool. I'm going to take a closer look later. It would be very interesting to have a centralized solution for this new "problem" of having code that runs on Linux as well. Willing to contribute to this!

Talking about another matter that it's very important, as well. I think it was you who did a post about using pure swift frameworks in command line applications by faking a bundle, was it? Is there another way? Swift not having a stable ABI sucks, and they (apple) have no clue when it'll happen.

Having some sort of package management like NPM and the likes would be awesome too, because the current ones (cocoapod, carthage) aren't doing the trick. Will they ever?

Sorry for using an issue to contact here. Is there a better way to contact another user in github?

Hey folks, I'm working on a project that requires DateFormatter support. Is this on the roadmap for this project? If it's not, is this feature something you'd accept in a contribution?

• Updated types for Swift 5 API compatibility.
• Removed all non-standard (Apple) Foundation API.
• Removed Carthage support
• Added WASM support
• Updated unit tests

Motivation

Apple has finally implemented Pure Swift value types for Foundation in Swift 3.0, but there are some issues with this:

• Only a subset of types like Date are truly value type structs, the rest are structs, but backed by a reference type.
• JSON is still AnyObject, not an enum
• OSS Foundation is huge, will still have the CoreFoundation codebase, and it will still keep the NS* classes. This is not desirable for a Pure Swift portable library.
• With Xcode, SwiftFoundation is a PITA to use because the types conflict with the new Foundation value types, which are imported implicitly.
• They have only implemented this as a Swift addition in Darwin, the Linux support is still lacking, hence making this project still necessary.
• This project provides a lot of functionality that OSS Foundation does not provide.
• The compiled binary for this project is tiny compared to OSS Foundation.
• OSS Foundation still depends on non-posix C libraries like CoreFoundation
• Not as portable as SwiftFoundation because it's not truly Pure Swift.

Solution

• Make conflicting types only compile on Linux. On Darwin we will remove the implementation of conflicting types, and make any additions extensions (e.g. RawRepresentable for UUID).
• Update APIs to have to mirror the Darwin APIs
• Keep all additions (e.g. HTTP.StatusCode, Null, JSON.Value) for both platforms.
• Remove FoundationConvertible since ReferenceConvertible exists.

This is because the JSONParse.swift uses the JSON module on OS X:

https://github.com/PureSwift/SwiftFoundation/blob/develop/Sources/SwiftFoundation/JSONParse.swift#L9

but in the Package.swift the CJSONC module is defined as a dependancy instead:

https://github.com/PureSwift/SwiftFoundation/blob/develop/Package.swift#L8

Is there a reason for no using CJSONC on OS X or vice versa for JSON on Linux?