@spec cd(Path.t()) :: :ok | {:error,posix()}

Sets the current working directory.

The current working directory is set for the BEAM globally. This can lead torace conditions if multiple processes are changing the current workingdirectory concurrently. To run an external command in a given directorywithout changing the global current working directory, use the:cd optionofSystem.cmd/3 andPort.open/2.

Returns:ok if successful,{:error, reason} otherwise.

@spec cd!(Path.t()) :: :ok

The same ascd/1, but raises aFile.Error exception if it fails.

@spec cd!(Path.t(), (-> res)) :: res when res: var

Changes the current directory to the givenpath,executes the given function and then reverts backto the previous path regardless of whether there is an exception.

The current working directory is temporarily set for the BEAM globally. Thiscan lead to race conditions if multiple processes are changing the currentworking directory concurrently. To run an external command in a givendirectory without changing the global current working directory, use the:cd option ofSystem.cmd/3 andPort.open/2.

Raises an error if retrieving or changing the currentdirectory fails.

@spec chgrp(Path.t(),non_neg_integer()) :: :ok | {:error,posix()}

Changes the group given by the group IDgidfor a givenfile. Returns:ok on success, or{:error, reason} on failure.

@spec chgrp!(Path.t(),non_neg_integer()) :: :ok

Same aschgrp/2, but raises aFile.Error exception in case of failure.Otherwise:ok.

@spec chmod(Path.t(),non_neg_integer()) :: :ok | {:error,posix()}

Changes themode for a givenfile.

Returns:ok on success, or{:error, reason} on failure.

Permissions

File permissions are specified by adding together the following octal modes:

• 0o400 - read permission: owner

• 0o200 - write permission: owner

• 0o100 - execute permission: owner

• 0o040 - read permission: group

• 0o020 - write permission: group

• 0o010 - execute permission: group

• 0o004 - read permission: other

• 0o002 - write permission: other

• 0o001 - execute permission: other

For example, setting the mode0o755 gives itwrite, read and execute permission to the ownerand both read and execute permission to groupand others.

@spec chmod!(Path.t(),non_neg_integer()) :: :ok

Same aschmod/2, but raises aFile.Error exception in case of failure.Otherwise:ok.

@spec chown(Path.t(),non_neg_integer()) :: :ok | {:error,posix()}

Changes the owner given by the user IDuidfor a givenfile. Returns:ok on success,or{:error, reason} on failure.

@spec chown!(Path.t(),non_neg_integer()) :: :ok

Same aschown/2, but raises aFile.Error exception in case of failure.Otherwise:ok.

@spec close(io_device()) :: :ok | {:error,posix() | :badarg | :terminated}

Closes the file referenced byio_device. It mostly returns:ok, exceptfor some severe errors such as out of memory.

Note that if the option:delayed_write was used when opening the file,close/1 might return an old write error and not even try to close the file.Seeopen/2 for more information.

@spec copy(Path.t() |io_device(),Path.t() |io_device(),pos_integer() | :infinity) ::  {:ok,non_neg_integer()} | {:error,posix()}

Copies the contents ofsource todestination.

Both parameters can be a filename or an IO device openedwithopen/2.bytes_count specifies the number ofbytes to copy, the default being:infinity.

If filedestination already exists, it is overwrittenby the contents insource.

Returns{:ok, bytes_copied} if successful,{:error, reason} otherwise.

Compared to thecp/3, this function is more low-level,allowing a copy from device to device limited by a number ofbytes. On the other hand,cp/3 performs more extensivechecks on both source and destination and it also preservesthe file mode after copy.

Typical error reasons are the same as inopen/2,read/1 andwrite/3.

@spec copy!(Path.t() |io_device(),Path.t() |io_device(),pos_integer() | :infinity) ::non_neg_integer()

The same ascopy/3 but raises aFile.CopyError exception if it fails.Returns thebytes_copied otherwise.

@spec cp(Path.t(),Path.t(), [{:on_conflict,on_conflict_callback()}]) ::  :ok | {:error,posix()}

Copies the contents ofsource_file todestination_file preserving its modes.

source_file must be a file or a symbolic link to one.destination_file mustbe a path to a non-existent file. If either is a directory,{:error, :eisdir}will be returned.

The function returns:ok in case of success. Otherwise, it returns{:error, reason}.

If you want to copy contents from an IO device to another deviceor do a straight copy from a source to a destination withoutpreserving modes, checkcopy/3 instead.

Note: The commandcp in Unix-like systems behaves differently depending onwhether the destination is an existing directory or not. We have chosen toexplicitly disallow copying to a destination which is a directory,and an error will be returned if tried.

Options

• :on_conflict - (since v1.14.0) Invoked when a file already exists in the destination.The function receives arguments forsource_file anddestination_file. It shouldreturntrue if the existing file should be overwritten,false if otherwise.The default callback returnstrue. On earlier versions, this callback could begiven as third argument, but such behavior is now deprecated.

@spec cp!(Path.t(),Path.t(), [{:on_conflict,on_conflict_callback()}]) :: :ok

The same ascp/3, but raises aFile.CopyError exception if it fails.Returns:ok otherwise.

@spec cp_r(Path.t(),Path.t(),  on_conflict:on_conflict_callback(),  dereference_symlinks:boolean()) ::  {:ok, [binary()]} | {:error,posix(),binary()}

Copies the contents insource todestination recursively, maintaining thesource directory structure and modes.

Ifsource is a file or a symbolic link to it,destination must be a pathto an existent file, a symbolic link to one, or a path to a non-existent file.

Ifsource is a directory, or a symbolic link to it, thendestination mustbe an existentdirectory or a symbolic link to one, or a path to a non-existent directory.

If the source is a file, it copiessource todestination. If thesourceis a directory, it copies the contents inside source into thedestination directory.

If a file already exists in the destination, it invokes the optionalon_conflictcallback given as an option. See "Options" for more information.

This function may fail while copying files, in such cases, it will leave thedestination directory in a dirty state, where file which have already beencopied won't be removed.

The function returns{:ok, files_and_directories} in case ofsuccess,files_and_directories lists all files and directories copied in nospecific order. It returns{:error, reason, file} otherwise.

Note: The commandcp in Unix-like systems behaves differently depending onwhetherdestination is an existing directory or not. We have chosen toexplicitly disallow this behavior. Ifsource is afile anddestinationis a directory,{:error, :eisdir} will be returned.

Options

• :on_conflict - (since v1.14.0) Invoked when a file already exists in the destination.The function receives arguments forsource anddestination. It should returntrue if the existing file should be overwritten,false if otherwise. The defaultcallback returnstrue. On earlier versions, this callback could be given as thirdargument, but such behavior is now deprecated.

• :dereference_symlinks - (since v1.14.0) By default, this function will copy symlinksby creating symlinks that point to the same location. This option forces symlinks to bedereferenced and have their contents copied instead when set totrue. If the dereferencedfiles do not exist, than the operation fails. The default isfalse.

Examples

# Copies file "a.txt" to "b.txt"File.cp_r("a.txt","b.txt")# Copies all files in "samples" to "tmp"File.cp_r("samples","tmp")# Same as before, but asks the user how to proceed in case of conflictsFile.cp_r("samples","tmp",on_conflict:fnsource,destination->IO.gets("Overwriting#{destination} by#{source}. Type y to confirm. ")=="y\n"end)

@spec cp_r!(Path.t(),Path.t(),  on_conflict:on_conflict_callback(),  dereference_symlinks:boolean()) ::  [binary()]

The same ascp_r/3, but raises aFile.CopyError exception if it fails.Returns the list of copied files otherwise.

@spec cwd() :: {:ok,binary()} | {:error,posix()}

Gets the current working directory.

In rare circumstances, this function can fail on Unix-like systems. It may happenif read permissions do not exist for the parent directories of thecurrent directory. For this reason, returns{:ok, cwd} in caseof success,{:error, reason} otherwise.

@spec cwd!() ::binary()

The same ascwd/0, but raises aFile.Error exception if it fails.

@spec dir?(Path.t(), [dir_option]) ::boolean() when dir_option: :raw

Returnstrue if the given path is a directory.

This function follows symbolic links, so if a symbolic link points to adirectory,true is returned.

Options

The supported options are:

• :raw - a single atom to bypass the file server and only checkfor the file locally

Examples

File.dir?("./test")#=> trueFile.dir?("test")#=> trueFile.dir?("/usr/bin")#=> trueFile.dir?("~/Downloads")#=> false"~/Downloads"|>Path.expand()|>File.dir?()#=> true

@spec exists?(Path.t(), [exists_option]) ::boolean() when exists_option: :raw

Returnstrue if the given path exists.

It can be a regular file, directory, socket, symbolic link, named pipe, or device file.Returnsfalse for symbolic links pointing to non-existing targets.

Options

The supported options are:

• :raw - a single atom to bypass the file server and only checkfor the file locally

Examples

File.exists?("test/")#=> trueFile.exists?("missing.txt")#=> falseFile.exists?("/dev/null")#=> true

@spec ln(Path.t(),Path.t()) :: :ok | {:error,posix()}

Creates a hard linknew to the fileexisting.

Returns:ok if successful,{:error, reason} otherwise.If the operating system does not support hard links, returns{:error, :enotsup}.

@spec ln!(Path.t(),Path.t()) :: :ok

Same asln/2 but raises aFile.LinkError exception if it fails.Returns:ok otherwise.

@spec ln_s(Path.t(),Path.t()) :: :ok | {:error,posix()}

Creates a symbolic linknew to the file or directoryexisting.

Returns:ok if successful,{:error, reason} otherwise.If the operating system does not support symlinks, returns{:error, :enotsup}.

@spec ln_s!(Path.t(),Path.t()) :: :ok

Same asln_s/2 but raises aFile.LinkError exception if it fails.Returns:ok otherwise.

@spec ls(Path.t()) :: {:ok, [binary()]} | {:error,posix()}

Returns the list of files in the given directory.

Hidden files are not ignored and the results arenot sorted.

Since directories are considered files by the file system,they are also included in the returned value.

Returns{:ok, files} in case of success,{:error, reason} otherwise.

@spec ls!(Path.t()) :: [binary()]

The same asls/1 but raises aFile.Error exception in case of an error.

@spec lstat(Path.t(),stat_options()) :: {:ok,File.Stat.t()} | {:error,posix()}

Returns information about thepath. If the file is a symlink, setsthetype to:symlink and returns aFile.Stat struct for the link. For anyother file, returns exactly the same values asstat/2.

For more details, see:file.read_link_info/2.

Options

The accepted options are:

• :time - configures how the file timestamps are returned

The values for:time can be:

• :universal - returns a{date, time} tuple in UTC (default)
• :local - returns a{date, time} tuple using the machine time
• :posix - returns the time as integer seconds since epoch

Note: Since file times are stored in POSIX time format on most operating systems,it is faster to retrieve file information with thetime: :posix option.

@spec lstat!(Path.t(),stat_options()) ::File.Stat.t()

Same aslstat/2 but returns theFile.Stat struct directly,or raises aFile.Error exception if an error is returned.

@spec mkdir(Path.t()) :: :ok | {:error,posix()}

Tries to create the directorypath.

Missing parent directories are not created.Returns:ok if successful, or{:error, reason} if an error occurs.

Typical error reasons are:

• :eacces - missing search or write permissions for the parentdirectories ofpath
• :eexist - there is already a file or directory namedpath
• :enoent - a component ofpath does not exist
• :enospc - there is no space left on the device
• :enotdir - a component ofpath is not a directory;on some platforms,:enoent is returned instead

@spec mkdir!(Path.t()) :: :ok

Same asmkdir/1, but raises aFile.Error exception in case of failure.Otherwise:ok.

@spec mkdir_p(Path.t()) :: :ok | {:error,posix()}

Tries to create the directorypath.

Missing parent directories are created. Returns:ok if successful, or{:error, reason} if an error occurs.

Typical error reasons are:

• :eacces - missing search or write permissions for the parentdirectories ofpath
• :enospc - there is no space left on the device
• :enotdir - a component ofpath is not a directory

@spec mkdir_p!(Path.t()) :: :ok

Same asmkdir_p/1, but raises aFile.Error exception in case of failure.Otherwise:ok.

@spec open(Path.t(), [mode() | :ram]) ::  {:ok,io_device() |file_descriptor()} | {:error,posix()}

@spec open(Path.t(), (io_device() |file_descriptor() -> res)) ::  {:ok, res} | {:error,posix()}when res: var

Opens the givenpath.

modes_or_function can either be a list of modes or a function. If it's alist, it's considered to be a list of modes (that are documented below). Ifit's a function, then it's equivalent to callingopen(path, [], modes_or_function). See the documentation foropen/3 for more informationon this function.

The allowed modes:

• :binary - opens the file in binary mode, disabling special handling ofUnicode sequences (default mode).

• :read - the file, which must exist, is opened for reading.

• :write - the file is opened for writing. It is created if it does notexist.

  If the file does exist, and if write is not combined with read, the filewill be truncated.

• :append - the file will be opened for writing, and it will be createdif it does not exist. Every write operation to a file opened with appendwill take place at the end of the file.

• :exclusive - the file, when opened for writing, is created if it doesnot exist. If the file exists, open will return{:error, :eexist}.

• :charlist - when this term is given, read operations on the file willreturn charlists rather than binaries.

• :compressed - makes it possible to read or write gzip compressed files.

  The compressed option must be combined with either read or write, but notboth. Note that the file size obtained withstat/1 will most probablynot match the number of bytes that can be read from a compressed file.

• :utf8 - this option denotes how data is actually stored in the diskfile and makes the file perform automatic translation of characters toand from UTF-8.

  If data is sent to a file in a format that cannot be converted to theUTF-8 or if data is read by a function that returns data in a format thatcannot cope with the character range of the data, an error occurs and thefile will be closed.

• :delayed_write,:raw,:ram,:read_ahead,:sync,{:encoding, ...},{:read_ahead, pos_integer},{:delayed_write, non_neg_integer, non_neg_integer} -for more information about these options see:file.open/2.

This function returns:

• {:ok, io_device | file_descriptor} - the file has been opened inthe requested mode. We explore the differences between these two resultsin the following section

• {:error, reason} - the file could not be opened due toreason.

IO devices

By default, this function returns an IO device. Anio_device isa process which handles the file and you can interact with it usingthe functions in theIO module. By default, a file is opened in:binary mode, which requires the functionsIO.binread/2 andIO.binwrite/2 to interact with the file. A developer may pass:utf8as a mode when opening the file and then all other functions fromIO are available, since they work directly with Unicode data.

Given the IO device is a file, if the owner process terminates,the file is closed and the process itself terminates too. If anyprocess to which theio_device is linked terminates, the filewill be closed and the process itself will be terminated.

File descriptors

When the:raw or:ram modes are given, this function returnsa low-level file descriptors. This avoids creating a process butrequires using the functions in the:file module tointeract with it.

Examples

{:ok,file}=File.open("foo.tar.gz",[:read,:compressed])IO.read(file,:line)File.close(file)

@spec open(Path.t(), [mode() | :ram], (io_device() |file_descriptor() -> res)) ::  {:ok, res} | {:error,posix()}when res: var

Similar toopen/2 but expects a function as its last argument.

The file is opened, given to the function as an argument andautomatically closed after the function returns, regardlessif there was an error when executing the function.

Returns{:ok, function_result} in case of success,{:error, reason} otherwise.

This function expects the file to be closed with success,which is usually the case unless the:delayed_write optionis given. For this reason, we do not recommend passing:delayed_write to this function.

Examples

File.open("file.txt",[:read,:write],fnfile->IO.read(file,:line)end)

Seeopen/2 for the list of availablemodes.

@spec open!(Path.t(), [mode() | :ram]) ::io_device() |file_descriptor()

@spec open!(Path.t(), (io_device() |file_descriptor() -> res)) :: res when res: var

Similar toopen/2 but raises aFile.Error exception if the filecould not be opened. Returns the IO device otherwise.

Seeopen/2 for the list of available modes.

@spec open!(Path.t(), [mode() | :ram], (io_device() |file_descriptor() -> res)) ::  reswhen res: var

Similar toopen/3 but raises aFile.Error exception if the filecould not be opened.

If it succeeds opening the file, it returns thefunction result on the IO device.

Seeopen/2 for the list of availablemodes.

@spec read(Path.t()) :: {:ok,binary()} | {:error,posix()}

Returns{:ok, binary}, wherebinary is a binary data object that contains the contentsofpath, or{:error, reason} if an error occurs.

Typical error reasons:

• :enoent - the file does not exist
• :eacces - missing permission for reading the file,or for searching one of the parent directories
• :eisdir - the named file is a directory
• :enotdir - a component of the file name is not a directory;on some platforms,:enoent is returned instead
• :enomem - there is not enough memory for the contents of the file

You can use:file.format_error/1 to get a descriptive string of the error.

@spec read!(Path.t()) ::binary()

Returns a binary with the contents of the given filename,or raises aFile.Error exception if an error occurs.

@spec read_link(Path.t()) :: {:ok,binary()} | {:error,posix()}

Reads the symbolic link atpath.

Ifpath exists and is a symlink, returns{:ok, target}, otherwise returns{:error, reason}.

For more details, see:file.read_link/1.

Typical error reasons are:

• :einval - path is not a symbolic link
• :enoent - path does not exist
• :enotsup - symbolic links are not supported on the current platform

@spec read_link!(Path.t()) ::binary()

Same asread_link/1 but returns the target directly,or raises aFile.Error exception if an error is returned.

@spec regular?(Path.t(), [regular_option]) ::boolean() when regular_option: :raw

Returnstrue if the path is a regular file.

This function follows symbolic links, so if a symbolic link points to aregular file,true is returned.

Options

The supported options are:

• :raw - a single atom to bypass the file server and only checkfor the file locally

Examples

File.regular?(__ENV__.file)#=> true

@spec rename(Path.t(),Path.t()) :: :ok | {:error,posix()}

Renames thesource file todestination file. It can be used to move files(and directories) between directories. If moving a file, you must fullyspecify thedestination filename, it is not sufficient to simply specifyits directory.

Returns:ok in case of success,{:error, reason} otherwise.

Note: The commandmv in Unix-like systems behaves differently depending onwhethersource is a file and thedestination is an existing directory.We have chosen to explicitly disallow this behavior.

Examples

# Rename file "a.txt" to "b.txt"File.rename("a.txt","b.txt")# Rename directory "samples" to "tmp"File.rename("samples","tmp")

@spec rename!(Path.t(),Path.t()) :: :ok

The same asrename/2 but raises aFile.RenameError exception if it fails.Returns:ok otherwise.

@spec rm(Path.t()) :: :ok | {:error,posix()}

Tries to delete the filepath.

Returns:ok if successful, or{:error, reason} if an error occurs.

Note the file is deleted even if in read-only mode.

Typical error reasons are:

• :enoent - the file does not exist
• :eacces - missing permission for the file or one of its parents
• :eperm - the file is a directory and user is not super-user
• :enotdir - a component of the file name is not a directory;on some platforms,:enoent is returned instead
• :einval - filename had an improper type, such as tuple

Examples

File.rm("file.txt")#=> :okFile.rm("tmp_dir/")#=> {:error, :eperm}

@spec rm!(Path.t()) :: :ok

Same asrm/1, but raises aFile.Error exception in case of failure.Otherwise:ok.

@spec rm_rf(Path.t()) :: {:ok, [binary()]} | {:error,posix(),binary()}

Removes files and directories recursively at the givenpath.Symlinks are not followed but simply removed, non-existingfiles are simply ignored (i.e. doesn't make this function fail).

Returns{:ok, files_and_directories} with all files anddirectories removed in no specific order,{:error, reason, file}otherwise.

Examples

File.rm_rf("samples")#=> {:ok, ["samples", "samples/1.txt"]}File.rm_rf("unknown")#=> {:ok, []}

@spec rm_rf!(Path.t()) :: [binary()]

Same asrm_rf/1 but raises aFile.Error exception in case of failures,otherwise the list of files or directories removed.

@spec rmdir(Path.t()) :: :ok | {:error,posix()}

Tries to delete the dir atpath.

Returns:ok if successful, or{:error, reason} if an error occurs.It returns{:error, :eexist} if the directory is not empty.

Examples

File.rmdir("tmp_dir")#=> :okFile.rmdir("non_empty_dir")#=> {:error, :eexist}File.rmdir("file.txt")#=> {:error, :enotdir}

@spec rmdir!(Path.t()) :: :ok | {:error,posix()}

Same asrmdir/1, but raises aFile.Error exception in case of failure.Otherwise:ok.

@spec stat(Path.t(),stat_options()) :: {:ok,File.Stat.t()} | {:error,posix()}

Returns information about thepath. If it exists, itreturns a{:ok, info} tuple, where info is aFile.Stat struct. Returns{:error, reason} withthe same reasons asread/1 if a failure occurs.

Options

The accepted options are:

• :time - configures how the file timestamps are returned

The values for:time can be:

• :universal - returns a{date, time} tuple in UTC (default)
• :local - returns a{date, time} tuple using the same time zone as themachine
• :posix - returns the time as integer seconds since epoch

Note: Since file times are stored in POSIX time format on most operating systems,it is faster to retrieve file information with thetime: :posix option.

@spec stat!(Path.t(),stat_options()) ::File.Stat.t()

Same asstat/2 but returns theFile.Stat directly,or raises aFile.Error exception if an error is returned.

@spec stream!(Path.t(), :line |pos_integer() | [stream_mode()]) ::File.Stream.t()

Shortcut forFile.stream!/3.

@spec stream!(Path.t(), :line |pos_integer(), [stream_mode()]) ::File.Stream.t()

Returns aFile.Stream for the givenpath with the givenmodes.

The stream implements bothEnumerable andCollectable protocols,which means it can be used both for read and write.

Theline_or_bytes argument configures how the file is read whenstreaming, by:line (default) or by a given number of bytes. Whenusing the:line option, CRLF line breaks ("\r\n") are normalizedto LF ("\n").

Similar to other file operations, a stream can be created in one nodeand forwarded to another node. Once the stream is opened in another node,a request will be sent to the creator node to spawn a process for filestreaming.

Operating the stream can fail on open for the same reasons asFile.open!/2. Note that the file is automatically opened each time streamingbegins. There is no need to pass:read and:write modes, as those areautomatically set by Elixir.

Raw files

Since Elixir controls when the streamed file is opened, the underlyingdevice cannot be shared and as such it is convenient to open the filein raw mode for performance reasons. Therefore, Elixirwill openstreams in:raw mode with the:read_ahead option if the stream isopen in the same node as it is created and no encoding has been specified.This means any data streamed into the file must be converted toiodata/0type. If you pass, for example,[encoding: :utf8] or[encoding: {:utf16, :little}] in the modes parameter, the underlying streamwill useIO.write/2 and theString.Chars protocol to convert the data.SeeIO.binwrite/2 andIO.write/2 .

One may also consider passing the:delayed_write option if the streamis meant to be written to under a tight loop.

Byte order marks and read offset

If you pass:trim_bom in the modes parameter, the stream willtrim UTF-8, UTF-16 and UTF-32 byte order marks when reading from file.

Note that this function does not try to discover the file encodingbased on BOM. From Elixir v1.16.0, you may also pass a:read_offsetthat is skipped whenever enumerating the stream (if both:read_offsetand:trim_bom are given, the offset is skipped after the BOM).

Examples

# Read a utf8 text file which may include BOMFile.stream!("./test/test.txt",[:trim_bom,encoding::utf8])# Read in 2048 byte chunks rather than linesFile.stream!("./test/test.data",2048)

SeeStream.run/1 for an example of streaming into a file.

@spec touch(Path.t(),erlang_time() |posix_time()) :: :ok | {:error,posix()}

Updates modification time (mtime) and access time (atime) ofthe given file.

The file is created if it doesn't exist. Requires datetime in UTC(as returned by:erlang.universaltime()) or an integerrepresenting the POSIX timestamp (as returned bySystem.os_time(:second)).

In Unix-like systems, changing the modification time may requireyou to be eitherroot or the owner of the file. Having writeaccess may not be enough. In those cases, touching the file thefirst time (to create it) will succeed, but touching an existingfile with fail with{:error, :eperm}.

Examples

File.touch("/tmp/a.txt",{{2018,1,30},{13,59,59}})#=> :okFile.touch("/fakedir/b.txt",{{2018,1,30},{13,59,59}}){:error,:enoent}File.touch("/tmp/a.txt",1544519753)#=> :ok

@spec touch!(Path.t(),erlang_time() |posix_time()) :: :ok

Same astouch/2 but raises aFile.Error exception if it fails.Returns:ok otherwise.

The file is created if it doesn't exist. Requires datetime in UTC(as returned by:erlang.universaltime()) or an integerrepresenting the POSIX timestamp (as returned bySystem.os_time(:second)).

Examples

File.touch!("/tmp/a.txt",{{2018,1,30},{13,59,59}})#=> :okFile.touch!("/fakedir/b.txt",{{2018,1,30},{13,59,59}})** (File.Error) could not touch "/fakedir/b.txt": no such file or directoryFile.touch!("/tmp/a.txt",1544519753)

@spec write(Path.t(),iodata(), [mode()]) :: :ok | {:error,posix()}

Writescontent to the filepath.

The file is created if it does not exist. If it exists, the previouscontents are overwritten. Returns:ok if successful, or{:error, reason}if an error occurs.

content must beiodata (a list of bytes or a binary). Setting theencoding for this function has no effect.

Warning: Every time this function is invoked, a file descriptor is openedand a new process is spawned to write to the file. For this reason, if you aredoing multiple writes in a loop, opening the file viaFile.open/2 and usingthe functions inIO to write to the file will yield much better performancethan calling this function multiple times.

Typical error reasons are:

• :enoent - a component of the file name does not exist
• :enotdir - a component of the file name is not a directory;on some platforms,:enoent is returned instead
• :enospc - there is no space left on the device
• :eacces - missing permission for writing the file or searching one ofthe parent directories
• :eisdir - the named file is a directory

CheckFile.open/2 for other available options.

@spec write!(Path.t(),iodata(), [mode()]) :: :ok

Same aswrite/3 but raises aFile.Error exception if it fails.Returns:ok otherwise.

@spec write_stat(Path.t(),File.Stat.t(),stat_options()) :: :ok | {:error,posix()}

Writes the givenFile.Stat back to the file system at the givenpath. Returns:ok or{:error, reason}.

@spec write_stat!(Path.t(),File.Stat.t(),stat_options()) :: :ok

Same aswrite_stat/3 but raises aFile.Error exception if it fails.Returns:ok otherwise.