filepath-1.4.100.4: Library for manipulating FilePaths in a cross platform way.

Safe Haskell | Safe-Inferred
Language | Haskell2010

System.OsPath.Internal

Synopsis

- encodeUtf :: MonadThrow m => FilePath -> m OsPath
- encodeWith :: TextEncoding -> TextEncoding -> FilePath -> Either EncodingException OsPath
- encodeFS :: FilePath -> IO OsPath
- decodeUtf :: MonadThrow m => OsPath -> m FilePath
- decodeWith :: TextEncoding -> TextEncoding -> OsPath -> Either EncodingException FilePath
- decodeFS :: OsPath -> IO FilePath
- fromBytes :: MonadThrow m => ByteString -> m OsPath
- osp :: QuasiQuoter
- unpack :: OsPath -> [OsChar]
- pack :: [OsChar] -> OsPath

# Documentation

encodeUtf :: MonadThrow m => FilePath -> m OsPath Source #

Partial unicode friendly encoding.

On windows this encodes as UTF16-LE (strictly), which is a pretty good guess. On unix this encodes as UTF8 (strictly), which is a good guess.

Throws a `EncodingException` if encoding fails.

encodeWith Source #

Arguments

:: TextEncoding | unix text encoding
-> TextEncoding | windows text encoding
-> FilePath |
-> Either EncodingException OsPath |

Encode a `FilePath` with the specified encoding.

encodeFS :: FilePath -> IO OsPath Source #

Like `encodeUtf`, except this mimics the behavior of the base library when doing filesystem operations, which is:

1. on unix, uses shady PEP 383 style encoding (based on the current locale, but PEP 383 only works properly on UTF-8 encodings, so good luck)
2. on windows does permissive UTF-16 encoding, where coding errors generate Chars in the surrogate range

Looking up the locale requires IO. If you're not worried about calls to `setFileSystemEncoding`, then `unsafePerformIO` may be feasible (make sure to deeply evaluate the result to catch exceptions).

decodeUtf :: MonadThrow m => OsPath -> m FilePath Source #

Partial unicode friendly decoding.

On windows this decodes as UTF16-LE (strictly), which is a pretty good guess. On unix this decodes as UTF8 (strictly), which is a good guess.

Throws a `EncodingException` if decoding fails.

decodeWith Source #

Arguments

:: TextEncoding | unix text encoding
-> TextEncoding | windows text encoding
-> OsPath |
-> Either EncodingException FilePath |

Decode an `OsPath` with the specified encoding.

decodeFS :: OsPath -> IO FilePath Source #

Like `decodeUtf`, except this mimics the behavior of the base library when doing filesystem operations, which is:

1. on unix, uses shady PEP 383 style encoding (based on the current locale, but PEP 383 only works properly on UTF-8 encodings, so good luck)
2. on windows does permissive UTF-16 encoding, where coding errors generate Chars in the surrogate range

Looking up the locale requires IO. If you're not worried about calls to `setFileSystemEncoding`, then `unsafePerformIO` may be feasible (make sure to deeply evaluate the result to catch exceptions).

fromBytes :: MonadThrow m => ByteString -> m OsPath Source #

Constructs an `OsPath` from a ByteString.

On windows, this ensures valid UCS-2LE, on unix it is passed unchanged/unchecked.

Throws `EncodingException` on invalid UCS-2LE on windows (although unlikely).

osp :: QuasiQuoter Source #

QuasiQuote an `OsPath`. This accepts Unicode characters and encodes as UTF-8 on unix and UTF-16LE on windows. Runs `isValid` on the input.

unpack :: OsPath -> [OsChar] Source #

Unpack an `OsPath` to a list of `OsChar`.

pack :: [OsChar] -> OsPath Source #

Pack a list of `OsChar` to an `OsPath`.

Note that using this in conjunction with `unsafeFromChar` to convert from `[Char]` to `OsPath` is probably not what you want, because it will truncate unicode code points.