Rename a file

Rename a file
You are encouraged to solve this task according to the task description, using any language you may know.

Task

Rename:

•   a file called     input.txt     into     output.txt     and
•   a directory called     docs     into     mydocs.

This should be done twice:   once "here", i.e. in the current working directory and once in the filesystem root.

It can be assumed that the user has the rights to do so.

(In unix-type systems, only the user root would have sufficient permissions in the filesystem root.)

11l

Translation of: Python

fs:rename(‘input.txt’, ‘output.txt’)
fs:rename(‘docs’, ‘mydocs’)

fs:rename(fs:path:sep‘input.txt’, fs:path:sep‘output.txt’)
fs:rename(fs:path:sep‘docs’, fs:path:sep‘mydocs’)

Action!

The attached result has been obtained under DOS 2.5.

Library: Action! Tool Kit

INCLUDE "D2:IO.ACT" ;from the Action! Tool Kit

PROC Dir(CHAR ARRAY filter)
  BYTE dev=[1]
  CHAR ARRAY line(255)

  Close(dev)
  Open(dev,filter,6)
  DO
    InputSD(dev,line)
    PrintE(line)
    IF line(0)=0 THEN
      EXIT
    FI
  OD
  Close(dev)
RETURN

PROC Main()
  CHAR ARRAY filter="D:*.*",
    cmd="D:INPUT.TXT OUTPUT.TXT"

  Put(125) PutE() ;clear screen

  PrintF("Dir ""%S""%E",filter)
  Dir(filter)

  PrintF("Rename ""%S""%E%E",cmd)
  Rename(cmd)

  PrintF("Dir ""%S""%E",filter)
  Dir(filter)
RETURN

Output:

Screenshot from Atari 8-bit computer

Dir "D:*.*"
  DOS     SYS 037
  DUP     SYS 042
  INPUT   TXT 011
617 FREE SECTORS

Rename "D:INPUT.TXT OUTPUT.TXT"

Dir "D:*.*"
  DOS     SYS 037
  DUP     SYS 042
  OUTPUT  TXT 011
617 FREE SECTORS

Ada

with Ada.Directories;  use Ada.Directories;
   ...
Rename ("input.txt", "output.txt");
Rename ("docs", "mydocs");
Rename ("/input.txt", "/output.txt");
Rename ("/docs", "/mydocs");

The behavior depends on the concrete operating system regarding:

• file name encoding issues;
• file path notation (directory separator, directory syntax etc);
• file extension syntax;
• file system root (provided there is any).

ALGOL 68

Works with: ALGOL 68 version Standard - no extensions to language used

Note: reidf does not appear to be included in ALGOL 68G. Also note that file names would be Operating System dependent.

main:(
  PROC rename = (STRING source name, dest name)INT:
  BEGIN
    FILE actual file;
    INT errno = open(actual file, source name, stand back channel);
    IF errno NE 0 THEN
      errno
    ELSE
      IF reidf possible(actual file) THEN
        reidf(actual file, dest name); # change the identification of the book #
        errno
      ELSE
        close(actual file);
        -1
      FI
    FI
  END;
  rename("input.txt", "output.txt");
  rename("/input.txt", "/output.txt");
  rename("docs", "mydocs");
  rename("/docs", "/mydocs")
)

Arturo

fileFrom: "input.txt"
fileTo:   "output.txt"
docsFrom: "docs"
docsTo:   "mydocs"

rename fileFrom fileTo
rename.directory docsFrom docsTo

rename join.path ["/" fileFrom] 
       join.path ["/" fileTo]

rename.directory join.path ["/" docsFrom]
                 join.path ["/" docsTo]

AutoHotkey

FileMove, oldname, newname

AutoIt

FileMove("input.txt", "output.txt") FileMove("\input.txt", "\output.txt") DirMove("docs", "mydocs") DirMove("\docs", "\mydocs")

AWK

Awk allows to call operating system commands with the system() function. However, the awk script won't get its output, only the return code. But this task is simple enough for the trivial implementation to work:

$ awk 'BEGIN{system("mv input.txt output.txt")}'
$ awk 'BEGIN{system("mv docs mydocs")}'
$ awk 'BEGIN{system("mv /input.txt /output.txt")}'
$ awk 'BEGIN{system("mv docs mydocs")}'

BaCon

RENAME "input.txt" TO "output.txt"
RENAME "/input.txt" TO "/output.txt"
RENAME "docs" TO "mydocs"
RENAME "/docs" TO "/mydocs"

BASIC

NAME "input.txt" AS "output.txt"
NAME "\input.txt" AS "\output.txt"
NAME "docs" AS "mydocs"
NAME "\docs" AS "\mydocs"

Applesoft BASIC

Apple DOS 3.3 has a flat filesystem with no concept of directories. DOS commands such as RENAME are run directly from the Applesoft prompt but are not technically part of Applesoft BASIC. Thus, attempting to add this line to a program and run it results in a syntax error on that line.

RENAME INPUT.TXT,OUTPUT.TXT

To use a DOS command from a program, use the BASIC statement PRINT followed by CHR$(4) and the string containing the DOS command.

10  PRINT  CHR$ (4)"RENAME INPUT.TXT,OUTPUT.TXT"

Apple ProDOS does have directories. To change the current working directory to the "root" directory, issue a PREFIX / command.

10  PRINT  CHR$ (4)"RENAME INPUT.TXT,OUTPUT.TXT"
20  PRINT  CHR$ (4)"RENAME DOCS,MYDOCS"
30  PRINT  CHR$ (4)"PREFIX /"
40  PRINT  CHR$ (4)"RENAME INPUT.TXT,OUTPUT.TXT"
50  PRINT  CHR$ (4)"RENAME DOCS,MYDOCS"

Commodore BASIC

Works with Commodore BASIC V2.0 as follows:

OPEN 15,<Device>,15,"R<DRIVE>:FilenameOLD=FilenameNEW":CLOSE 15

Works with Commodore BASIC 3.5 and above as follows:

RENAME <FilenameOLD>[,D<DRIVE>] TO <FilenameNEW> [ON U<Deviceadress>]

ZX Spectrum Basic

The ZX Spectrum basic does not not have a facility to rename a file on the microdrive. To rename a file, it is necessary to delete the file and recreate it. Alternatively, a machine code program can be used to achieve this.

Batch File

ren input.txt output.txt
ren \input.txt output.txt
ren docs mydocs
ren \docs mydocs

BBC BASIC

Works with: BBC BASIC for Windows

When the file or directory names are known as constants at 'compile time':

      *RENAME input.txt output.txt
      *RENAME \input.txt \output.txt
      *RENAME docs. mydocs.
      *RENAME \docs. \mydocs.

When the file or directory names are known only at run time:

      OSCLI "RENAME input.txt output.txt"
      OSCLI "RENAME \input.txt \output.txt"
      OSCLI "RENAME docs. mydocs."
      OSCLI "RENAME \docs. \mydocs."

Bracmat

ren$("input.txt"."output.txt")         { 'ren' is based on standard C function 'rename()' }
ren$(docs.mydocs)                      { No quotes needed: names don't contain dots or colons. }
ren$("d:\\input.txt"."d:\\output.txt") { Backslash is escape character, so we need to escape it. }
ren$(@"d:\docs".@"d:\mydocs")          { @ used as syntactic sugar as in C# for inhibiting escape. }

C

#include <stdio.h>

int main()
{
  rename("input.txt", "output.txt");
  rename("docs", "mydocs");
  rename("/input.txt", "/output.txt");
  rename("/docs", "/mydocs");
  return 0;
}

C#

using System;
using System.IO;

class Program {
    static void Main(string[] args) {
        File.Move("input.txt","output.txt");
        File.Move(@"\input.txt",@"\output.txt");

        Directory.Move("docs","mydocs");
        Directory.Move(@"\docs",@"\mydocs");
    }
}

C++

Translation of: C

#include <cstdio>

int main()
{
    std::rename("input.txt", "output.txt");
    std::rename("docs", "mydocs");
    std::rename("/input.txt", "/output.txt");
    std::rename("/docs", "/mydocs");
    return 0;
}

Library: Boost

compiled with g++ -lboost_system -lboost_filesystem

#include "boost/filesystem.hpp"

int main()
{
    boost::filesystem::rename(
        boost::filesystem::path("input.txt"),
        boost::filesystem::path("output.txt"));
    boost::filesystem::rename(
        boost::filesystem::path("docs"),
        boost::filesystem::path("mydocs"));
    boost::filesystem::rename(
        boost::filesystem::path("/input.txt"),
        boost::filesystem::path("/output.txt"));
    boost::filesystem::rename(
        boost::filesystem::path("/docs"),
        boost::filesystem::path("/mydocs"));*/
    return 0;
}

Clipper

FRename( "input.txt","output.txt")
or
RENAME input.txt TO output.txt

FRename("\input.txt","\output.txt")
or
RENAME \input.txt TO \output.txt

Clipper has no it's own functions to rename a directory, it is possible, though, to write appropriate code in C and link it to Clipper application, using the Clipper's Extend system.

Clojure

(import '(java.io File))

(.renameTo (File. "input.txt") (File. "output.txt"))
(.renameTo (File. "docs") (File. "mydocs"))

(.renameTo 
 (File. (str (File/separator) "input.txt"))
 (File. (str (File/separator) "output.txt")))
(.renameTo 
 (File. (str (File/separator) "docs"))
 (File. (str (File/separator) "mydocs")))

Common Lisp

rename-file

(rename-file "input.txt" "output.txt")
(rename-file "docs" "mydocs")
(rename-file "/input.txt" "/output.txt")
(rename-file "/docs" "/mydocs")

D

std.file.rename("input.txt","output.txt");
std.file.rename("/input.txt","/output.txt");
std.file.rename("docs","mydocs");
std.file.rename("/docs","/mydocs");

DBL

XCALL RENAM ("output.txt","input.txt")
.IFDEF UNIX
XCALL SPAWN ("mv docs mydocs")
.ENDC
.IFDEF DOS
XCALL SPAWN ("ren docs mydocs")
.ENDC
.IFDEF VMS
XCALL SPAWN ("rename docs.dir mydocs.dir")
.ENDC

DCL

rename input.txt output.txt
rename docs.dir mydocs.dir
rename [000000]input.txt [000000]output.txt
rename [000000]docs.dir [000000]mydocs.dir

Delphi

program RenameFile;

{$APPTYPE CONSOLE}

uses SysUtils;

begin
  SysUtils.RenameFile('input.txt', 'output.txt');
  SysUtils.RenameFile('\input.txt', '\output.txt');

  // RenameFile works for both files and folders
  SysUtils.RenameFile('docs', 'MyDocs');
  SysUtils.RenameFile('\docs', '\MyDocs');
end.

E

for where in [<file:.>, <file:///>] {
  where["input.txt"].renameTo(where["output.txt"], null)
  where["docs"].renameTo(where["mydocs"], null)
}

Elixir

File.rename "input.txt","output.txt"
File.rename "docs", "mydocs"
File.rename "/input.txt", "/output.txt"
File.rename "/docs", "/mydocs"

Emacs Lisp

(rename-file "input.txt" "output.txt")
(rename-file "/input.txt" "/output.txt")
(rename-file "docs" "mydocs")
(rename-file "/docs" "/mydocs")

This can also be done interactively with M-x rename-file. Programmatically the default is to throw an error if the new name already exists but the "ok-if-already-exists" parameter can either forcibly overwrite or query the user. Query is the default interactively.

Erlang

file:rename("input.txt","output.txt"),
file:rename( "docs", "mydocs" ),
file:rename( "/input.txt", "/output.txt" ),
file:rename( "/docs", "/mydocs" ).

ERRE

Renaming a file using ERRE language is a operating system-dependant operation. In PC version you must use the SHELL command like:

  CMD$="REN "+OLDFILENAME$+" "+NEWFILENAME$
  SHELL CMD$

with an obvious meaning of the string variables. You can specify a path using DOS conventions. In C64 version you must use

  OPEN(15,8,15,"R0:"+NF$+"="+OF$)
  CLOSE(15)

with an obvious meaning of the string variables.

F#

Translation of: C#

open System.IO
 
[<EntryPoint>]
let main args =
    File.Move("input.txt","output.txt")
    File.Move(@"\input.txt",@"\output.txt")
    Directory.Move("docs","mydocs")
    Directory.Move(@"\docs",@"\mydocs")
    0

Factor

"" "/" [ 
    [ "input.txt" "output.txt" move-file "docs" "mydocs" move-file ] with-directory
] bi@

Fantom

class Rename
{
  public static Void main ()
  {
    // rename file/dir in current directory
    File.rename("input.txt".toUri).rename("output.txt")
    File.rename("docs/".toUri).rename("mydocs/")
    // rename file/dir in root directory
    File.rename("/input.txt".toUri).rename("/output.txt")
    File.rename("/docs/".toUri).rename("/mydocs/")
  }
}

Forth

 s" input.txt"  s" output.txt" rename-file throw
s" /input.txt" s" /output.txt" rename-file throw

Fortran

Using UNIX extensions to Fortran 77 (see e.g. g77 manual) :

      PROGRAM EX_RENAME
      CALL RENAME('input.txt','output.txt')
      CALL RENAME('docs','mydocs')
      CALL RENAME('/input.txt','/output.txt')
      CALL RENAME('/docs','/mydocs')
      END

FreeBASIC

' FB 1.05.0 Win64

Dim result As Long
result = Name("input.txt", "output.txt")
If result <> 0 Then
  Print "Renaming file failed"
End If

result = Name("docs", "mydocs")
If result <> 0 Then
  Print "Renaming directory failed"
End If

Sleep

FutureBasic

CFURLRef inputText, outputText, docs, myDocs
inputText  = fn URLFileURLWithPath( @"~/Desktop/input.txt"  )
outputText = fn URLFileURLWithPath( @"~/Desktop/output.txt" )
docs       = fn URLFileURLWithPath( @"~/Desktop/docs/"      )
myDocs     = fn URLFileURLWithPath( @"~/Desktop/myDocs/"    )

fn FileManagerMoveItemAtURL( inputText, outputText )
fn FileManagerMoveItemAtURL(      docs, myDocs     )

Go

package main
import "os"

func main() {
  os.Rename("input.txt", "output.txt")
  os.Rename("docs", "mydocs")
  os.Rename("/input.txt", "/output.txt")
  os.Rename("/docs", "/mydocs")
}

Groovy

Using File

['input.txt':'output.txt', 'docs':'mydocs'].each { src, dst ->
  ['.', ''].each { dir ->
    new File("$dir/$src").renameTo(new File("$dir/$dst"))
  }
}

Using Ant

['input.txt':'output.txt', 'docs':'mydocs'].each { src, dst ->
  ['.', ''].each { dir ->
    new AntBuilder().move(file:"$dir/$src", toFile:"$dir/$dst")
  }
}

Harbour

FRename( "input.txt","output.txt")
// or
RENAME input.txt TO output.txt

FRename( hb_ps() + "input.txt", hb_ps() + "output.txt")

Harbour has no it's own functions to rename a directory, it is possible, though, to write appropriate code in C and link it to Harbour application, using the Harbour's Extend system.

Haskell

import System.IO
import System.Directory

main = do
  renameFile "input.txt" "output.txt"
  renameDirectory "docs" "mydocs"
  renameFile "/input.txt" "/output.txt"
  renameDirectory "/docs" "/mydocs"

HicEst

WRITE(FIle='input.txt', REName='.\output.txt')
SYSTEM(DIR='E:\HicEst\Rosetta')
WRITE(FIle='.\docs', REName='.\mydocs')

WRITE(FIle='\input.txt', REName='\output.txt')
SYSTEM(DIR='\')
WRITE(FIle='\docs', REName='\mydocs')

Icon and Unicon

Icon supports 'rename' for files only.

every dir := !["./","/"] do {
   rename(f := dir || "input.txt", dir || "output.txt")  |stop("failure for file rename ",f) 
   rename(f := dir || "docs", dir || "mydocs")           |stop("failure for directory rename ",f)
   }

Note: Icon and Unicon accept both / and \ for directory separators.

Io

// rename file in current directory
f := File with("input.txt")
f moveTo("output.txt")

// rename file in root directory
f := File with("/input.txt")
f moveTo("/output.txt")

// rename directory in current directory
d := Directory with("docs")
d moveTo("mydocs")

// rename directory in root directory
d := Directory with("/docs")
d moveTo("/mydocs")

J

J does not ship with a built-in utility for renaming files. The following will work on Windows, Linux and Macs:

frename=: 4 : 0
 if. x -: y do. return. end.
 if. IFUNIX do.
   hostcmd=. [: 2!:0 '('"_ , ] , ' || true)'"_
   hostcmd 'mv "',y,'" "',x,'"'
 else.
   'kernel32 MoveFileA i *c *c' 15!:0 y;x
 end.
)

Useage:

'output.txt' frename 'input.txt'
'/output.txt' frename '/input.txt'
'mydocs' frename 'docs'
'/mydocs' frename '/docs'

Java

import java.io.File;
public class FileRenameTest {
   public static boolean renameFile(String oldname, String newname) {
       // File (or directory) with old name
       File file = new File(oldname);
   
       // File (or directory) with new name
       File file2 = new File(newname);
   
       // Rename file (or directory)
       boolean success = file.renameTo(file2);
       return success;
   }
   public static void test(String type, String oldname, String newname) {
       System.out.println("The following " + type + " called " + oldname +
           ( renameFile(oldname, newname) ? " was renamed as " : " could not be renamed into ")
           + newname + "."
       );
   }
   public static void main(String args[]) {
        test("file", "input.txt", "output.txt");
        test("file", File.separator + "input.txt", File.separator + "output.txt");
        test("directory", "docs", "mydocs");
        test("directory", File.separator + "docs" + File.separator, File.separator + "mydocs" + File.separator);
   }
}

Using Java 11

On Windows OS administrative privileges are required to rename files in the root directory.

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;

public final class RenameAFile {

	public static void main(String[] args) throws IOException {
		List<Path> source =	List.of( Path.of("input.txt"),  Path.of("docs"),
                                     Path.of("C://input.txt") , Path.of("C://docs") );
	    List<Path> target = List.of( Path.of("output.txt"), Path.of("mydocs"),
                                     Path.of("C://output.txt"), Path.of("C://mydocs") );
	    
	    for ( int i = 0; i < source.size(); i++ ) {
	    	Files.move(source.get(i), target.get(i));
	    	System.out.println( Files.exists(target.get(i)) ? 
	    		"File '" + source.get(i) + "' successfully renamed to '" + target.get(i) + "'":
	    		"Unable to rename file: " + source.get(i));     
	    }  	
	}

}

Output:

File 'input.txt' successfully renamed to 'output.txt'
File 'docs' successfully renamed to 'mydocs'
File 'C:\input.txt' successfully renamed to 'C:\output.txt'
File 'C:\docs' successfully renamed to 'C:\mydocs'

JavaScript

Works with: JScript

Throws an error if the destination file/folder exists.

var fso = new ActiveXObject("Scripting.FileSystemObject")
fso.MoveFile("input.txt", "output.txt")
fso.MoveFile("c:/input.txt", "c:/output.txt")
fso.MoveFolder("docs", "mydocs")
fso.MoveFolder("c:/docs", "c:/mydocs")

Joy

"input.txt" "output.txt" frename
"/input.txt" "/output.txt" frename
"docs" "mydocs" frename
"/docs" "/mydocs" frename.

Jsish

/* File rename, in jsish */
try { File.rename('input.txt', 'output.txt', false); } catch (str) { puts(str); }

exec('touch input.txt');
puts("overwrite set true if output.txt exists");
File.rename('input.txt', 'output.txt', true);

try { File.rename('docs', 'mydocs', false); } catch (str) { puts(str); }
try { File.rename('/docs', '/mydocs', false); } catch (str) { puts(str); }

Julia

mv("input.txt", "output.txt")
mv("docs", "mydocs")
mv("/input.txt", "/output.txt")
mv("/docs", "/mydocs")

Kotlin

// version 1.0.6

/* testing on Windows 10 which needs administrative privileges
   to rename files in the root */
 
import java.io.File

fun main(args: Array<String>) {
    val oldPaths = arrayOf("input.txt", "docs", "c:\\input.txt", "c:\\docs")
    val newPaths = arrayOf("output.txt", "mydocs", "c:\\output.txt", "c:\\mydocs")
    var oldFile: File
    var newFile: File
    for (i in 0 until oldPaths.size) {
        oldFile = File(oldPaths[i])
        newFile = File(newPaths[i])
        if (oldFile.renameTo(newFile))
            println("${oldPaths[i]} successfully renamed to ${newPaths[i]}")
        else
            println("${oldPaths[i]} could not be renamed")
    }            
}

Output:

input.txt successfully renamed to output.txt
docs successfully renamed to mydocs
c:\input.txt successfully renamed to c:\output.txt
c:\docs successfully renamed to c:\mydocs

Lang

Library: lang-io-module

# Load the IO module
# Replace "<pathToIO.lm>" with the location where the io.lm Lang module was installed to without "<" and ">"
ln.loadModule(<pathToIO.lm>)

fp.rename = ($from, $to) -> {
	$fileFrom = [[io]]::fp.openFile($from)
	$fileTo = [[io]]::fp.openFile($to)
	
	[[io]]::fp.rename($fileFrom, $fileTo)
	
	[[io]]::fp.closeFile($fileFrom)
	[[io]]::fp.closeFile($fileTo)
}

fp.rename(input.txt, output.txt)
fp.rename(/input.txt, /output.txt)
fp.rename(docs, mydocs)
fp.rename(/docs, /mydocs)

Lasso

// move file
local(f = file('input.txt'))
#f->moveTo('output.txt')
#f->close

// move directory, just like a file
local(d = dir('docs'))
#d->moveTo('mydocs')

// move file in root file system (requires permissions at user OS level)
local(f = file('//input.txt'))
#f->moveTo('//output.txt')
#f->close

// move directory in root file system (requires permissions at user OS level)
local(d = file('//docs'))
#d->moveTo('//mydocs')

LFE

(file:rename "input.txt" "output.txt")
(file:rename "docs" "mydocs")
(file:rename "/input.txt" "/output.txt")
(file:rename "/docs" "/mydocs")

Liberty BASIC

'   LB has inbuilt 'name' command, but can also run batch files

nomainwin

name "input.txt" as "output.txt"
run "cmd.exe /c ren docs mydocs", HIDE
name "C:\input.txt" as "C:\output.txt"
run "cmd.exe /c ren C:\docs mydocs", HIDE

end

LiveCode

rename file "input.txt" to "output.txt"
rename folder "docs" to "mydocs"
rename file "/input.txt" to "/output.txt"
rename folder "/docs" to "/mydocs"

Locomotive Basic

|ren,"input.txt","output.txt"

(AMSDOS RSX command, therefore prefixed with a vertical bar. Also, there are no subdirectories in AMSDOS, so there is no way to do the other tests.)

Lua

os.rename( "input.txt", "output.txt" )
os.rename( "/input.txt", "/output.txt" )
os.rename( "docs", "mydocs" )
os.rename( "/docs", "/mydocs" )

M2000 Interpreter

To delete a file we have to use Dos shell,so this can be done using Dos command

Module checkit {
      Document A$={Alfa, beta}
      Save.Doc A$, "this.aaa"
      Print Exist("this.aaa")=true
      dos "cd "+quote$(dir$)+" && del this.bbb", 100;  ' using; to close dos window, and 100ms for waiting
      Name this.aaa as this.bbb
      Rem : Name "this.aaa" as "this.bbb"  ' we can use strings or variables
      Print Exist("this.bbb")=true
}
checkit

Maple

use FileTools in
  Rename( "input.txt", "output.txt" );
  Rename( "docs", "mydocs" );
  Rename( "/input.txt", "/output.txt" ); # assuming permissions in /
  Rename( "/docs", "/mydocs" )           # assuming permissions in /
end use:

Mathematica /Wolfram Language

SetDirectory[NotebookDirectory[]]
RenameFile["input.txt", "output.txt"]
RenameDirectory["docs", "mydocs"]
SetDirectory[$RootDirectory]
RenameFile["input.txt", "output.txt"]
RenameDirectory["docs", "mydocs"]

MATLAB / Octave

 [STATUS, MSG, MSGID] = movefile (F1, F2);

MAXScript

MAXScript has no folder rename method

-- Here
renameFile "input.txt" "output.txt"
-- Root
renameFile "/input.txt" "/output.txt"

Mercury

:- module rename_file.
:- interface.

:- import_module io.
:- pred main(io::di, io::uo) is det.

:- implementation.

:- import_module dir.

main(!IO) :-
    rename_file("input.txt", "output.txt", !IO),
    rename_file("docs", "mydocs", !IO),
    rename_file("/input.txt", "/output.txt", !IO),
    rename_file("/docs", "/mydocs", !IO).

:- pred rename_file(string::in, string::in, io::di, io::uo) is det.

rename_file(OldName, NewName, !IO) :-
    io.rename_file(OldName, NewName, Result, !IO),
    (
        Result = ok
    ;
        Result = error(Error),
        print_io_error(Error, !IO)
    ).

:- pred print_io_error(io.error::in, io::di, io::uo) is det.

print_io_error(Error, !IO) :-
   io.stderr_stream(Stderr, !IO),
   io.write_string(Stderr, io.error_message(Error), !IO),
   io.nl(Stderr, !IO),
   io.set_exit_status(1, !IO).

min

Works with: min version 0.37.0

"input.txt" "output.txt" mv
"docs" "mydocs" mv

"/input.txt" "/output.txt" mv
"/docs" "/mydocs" mv

MUMPS

ANSI MUMPS doesn't allow access to the operating system except possibly through the View command and $View function, both of which are implementation specific. Intersystems' Caché does allow you to create processes with the $ZF function, and if the permissions for the Caché process allow it you can perform operating system commands.

In Cache on OpenVMS in an FILES-11 filesystem ODS-5 mode these could work:

 ;Local
 S X=$ZF(-1,"rename input.txt output.txt")
 S X=$ZF(-1,"rename docs.dir mydocs.dir")
  ;Root of current device
 S X=$ZF(-1,"rename [000000]input.txt [000000]output.txt")
 S X=$ZF(-1,"rename [000000]docs.dir [000000]mydocs.dir")

NetRexx

/* NetRexx */
options replace format comments java crossref symbols binary

runSample(arg)
return

-- . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
method isFileRenamed(oldFile, newFile) public static returns boolean
  fo = File(oldFile)
  fn = File(newFile)
  fRenamed = fo.renameTo(fn)
  return fRenamed

-- 09:11, 27 August 2022 (UTC)09:11, 27 August 2022 (UTC)09:11, 27 August 2022 (UTC)09:11, 27 August 2022 (UTC)09:11, 27 August 2022 (UTC)09:11, 27 August 2022 (UTC)09:11, 27 August 2022 (UTC)09:11, 27 August 2022 (UTC)09:11, 27 August 2022 (UTC)09:11, 27 August 2022 (UTC)09:11, 27 August 2022 (UTC)09:11, 27 August 2022 (UTC)09:11, 27 August 2022 (UTC)09:11, 27 August 2022 (UTC)09:11, 27 August 2022 (UTC)~~
method runSample(arg) private static
  parse arg files
  if files = '' then files = 'input.txt output.txt F docs mydocs D /input.txt /output.txt F /docs /mydocs D'
  loop while files.length > 0
    parse files of nf ft files
    select case(ft.upper())
      when 'F' then do
        ft = 'File'
        end
      when 'D' then do
        ft = 'Directory'
        end
      otherwise do
        ft = 'File'
        end
      end
    if isFileRenamed(of, nf) then dl = 'renamed'
    else                          dl = 'not renamed'
    say ft ''''of'''' dl 'to' nf
    end

  return

NewLISP

(rename-file "./input.txt" "./output.txt")
(rename-file "./docs" "./mydocs")
(rename-file "/input.txt" "/output.txt")
(rename-file "/docs" "/mydocs")

Nim

import os

moveFile("input.txt", "output.txt")
moveFile("docs", "mydocs")

moveFile(DirSep & "input.txt", DirSep & "output.txt")
moveFile(DirSep & "docs", DirSep & "mydocs")

Objeck

use IO;
bundle Default {
  class FileExample {
    function : Main(args : String[]) ~ Nil {
      File->Rename("input.txt", "output.txt");
      File->Rename("docs", "mydocs");
      File->Rename("/input.txt", "/output.txt");
      File->Rename("/docs", "/mydocs");
    }
  }
}

Objective-C

Works with: Cocoa

Works with: GNUstep

NSFileManager *fm = [NSFileManager defaultManager];

// Pre-OS X 10.5
[fm movePath:@"input.txt" toPath:@"output.txt" handler:nil];
[fm movePath:@"docs" toPath:@"mydocs" handler:nil];

// OS X 10.5+
[fm moveItemAtPath:@"input.txt" toPath:@"output.txt" error:NULL];
[fm moveItemAtPath:@"docs" toPath:@"mydocs" error:NULL];

OCaml

let () =
  Sys.rename "input.txt" "output.txt";
  Sys.rename "docs" "mydocs";
  Sys.rename "/input.txt" "/output.txt";
  Sys.rename "/docs" "/mydocs";

Octave

rename('docs','mydocs');
rename('input.txt','/output.txt');
rename('/docs','/mydocs');

OpenEdge/Progress

OS-RENAME "input.txt" "output.txt".
OS-RENAME "docs" "mydocs".

OS-RENAME "/input.txt" "/output.txt".
OS-RENAME "/docs" "/mydocs".

PARI/GP

GP has no built-in facilities for renaming, but can use a system call:

system("mv input.txt output.txt");
system("mv /input.txt /output.txt");
system("mv docs mydocs");
system("mv /docs /mydocs");

PARI, as usual, has access to all the standard C methods.

Alternatively it's possible to bind rename() system call to a new function:

install("rename","iss","rename");
rename("input.txt", "output.txt");

Pascal

  var  
    f : file ; // Untyped file
 begin
 
  // as current directory
  AssignFile(f,'input.doc');
  Rename(f,'output.doc');
 
  // as root directory
  AssignFile(f,'\input.doc');
  Rename(f,'\output.doc');
 
  // rename a directory 
  AssignFile(f,'docs');
  Rename(f,'mydocs');
 
  //rename a directory off the root
 
  AssignFile(f,'\docs');
  Rename(f,'\mydocs');
 
end;

PascalABC.NET

uses System.IO;

begin
  &File.Move('input.txt','output.txt');
  &File.Move('\input.txt','\output.txt');

  Directory.Move('docs','mydocs');
  Directory.Move('\docs','\mydocs');
end.

Perl

use File::Copy qw(move);
use File::Spec::Functions qw(catfile rootdir);
# here
move 'input.txt', 'output.txt';
move 'docs', 'mydocs';
# root dir
move (catfile rootdir, 'input.txt'), (catfile rootdir, 'output.txt');
move (catfile rootdir, 'docs'), (catfile rootdir, 'mydocs');

The core rename($oldfile,$newfile) can rename a file within a directory, but has the usual limitations of the rename() system call or C library function, which means generally not working across filesystems, and perhaps not working to rename directories. move() does a copy and delete when necessary.

Phix

Windows now makes it fairly difficult to rename files in the root directory, even by hand. Output is 0 for success, 1 for failure.

without js -- (file i/o)
?rename_file("input.txt","output.txt")
?rename_file("docs","mydocs")
?rename_file("C:\\Copy.txt","Copy.xxx")
?rename_file("C:\\docs","C:\\mydocs")

Phixmonti

_platform "windows" == if "\\" "ren " else "/" "mv " endif
var com var slash

com "input.txt output.txt" chain cmd
com "docs mydocs" chain cmd
com slash chain "input.txt " chain slash chain "output.txt" chain cmd
com slash chain "docs " chain slash chain "mydocs" chain cmd

PHP

<?php
rename('input.txt', 'output.txt');
rename('docs', 'mydocs');
rename('/input.txt', '/output.txt');
rename('/docs', '/mydocs');
?>

PicoLisp

(call 'mv "input.txt" "output.txt")
(call 'mv "docs" "mydocs")
(call 'mv "/input.txt" "/output.txt")
(call 'mv "/docs" "/mydocs")

Pike

int main(){
   mv("input.txt", "output.txt");
   mv("/input.txt", "/output.txt");
   mv("docs", "mydocs");
   mv("/docs", "/mydocs");
}

Plain English

To run:
Start up.
\ In the current working directory
Rename ".\input.txt" to ".\output.txt" in the file system.
Rename ".\docs\" to ".\mydocs\" in the file system.
\ In the filesystem root
Rename "C:\input.txt" to "C:\output.txt" in the file system.
Rename "C:\docs\" to "C:\mydocs\" in the file system.
Shut down.

Pop11

sys_file_move('inputs.txt', 'output.txt');
sys_file_move('docs', 'mydocs');
sys_file_move('/inputs.txt', '/output.txt');
sys_file_move(/'docs', '/mydocs');

Note that notion of the root of filesystem is Unix specific, so above we do not try to suport other systems.

PowerShell

Rename-Item input.txt output.txt

# The Rename-item has the alias ren
ren input.txt output.txt

Processing

void setup(){
  boolean sketchfile = rename(sketchPath("input.txt"), sketchPath("output.txt"));
  boolean sketchfold = rename(sketchPath("docs"), sketchPath("mydocs"));
  // sketches will seldom have write permission to root files/folders
  boolean rootfile = rename("input.txt", "output.txt");
  boolean rootfold = rename("docs", "mydocs");
  // true if succeeded, false if failed
  println(sketchfile, sketchfold, rootfile, rootfold);  
}

boolean rename(String oldname, String newname) {
  // File (or directory) with old name
  File file = new File(oldname);
  // File (or directory) with new name
  File file2 = new File(newname);
  // Rename file (or directory)
  boolean success = file.renameTo(file2);
  return success;
}

Processing Python mode

from java.io import File

def setup():
    # rename local file
    sketchfile = rename(sketchPath("input.txt"), sketchPath("output.txt"))
    # rename local folder
    sketchfold = rename(sketchPath("docs"), sketchPath("mydocs"))
    # rename root file (if permitted)
    rootfile = rename("input.txt", "output.txt")
    # rename root folder (if permitted)
    rootfold = rename("docs", "mydocs")

    # display results of four operations: True=success, False=fail
    println(str(sketchfile) + ' ' +
            str(sketchfold) + ' ' +
            str(rootfile) +  ' ' +
            str(rootfold)) 
    # output:
    #     True True False False


def rename(oldname, newname):
    # File (or directory) with old name
    file = File(oldname)
    # File (or directory) with new name
    file2 = File(newname)
    # Rename file (or directory)
    success = file.renameTo(file2)
    return success

ProDOS

rename input.txt to output.txt
rename docs to mydocs

PureBasic

RenameFile("input.txt", "output.txt")
RenameFile("docs\", "mydocs\")

RenameFile("/input.txt","/output.txt")
RenameFile("/docs\","/mydocs\")

Python

import os

os.rename("input.txt", "output.txt")
os.rename("docs", "mydocs")

os.rename(os.sep + "input.txt", os.sep + "output.txt")
os.rename(os.sep + "docs", os.sep + "mydocs")

Or the alternative:

import shutil

shutil.move("input.txt", "output.txt")
shutil.move("docs", "mydocs")

shutil.move("/input.txt", "/output.txt")
shutil.move("/docs", "/mydocs")

Quackery

Quackery does not have a full set of file and directory handling words, so we pass a script string to the host language. A word could be defined in Quackery to construct the appropriate script string; this is the "once-off" version.

  $ "
import os
if os.path.exists('input.txt'):
    os.rename('input.txt', 'output.txt')
" python

  $ "
import os
if os.path.exists('docs'):
    os.rename('docs', 'mydocs')
" python

  $ "
import os
if os.path.exists('/input.txt'):
    os.rename('/input.txt', '/output.txt')
" python

  $ "
import os
if os.path.exists('/docs'):
    os.rename('/docs', '/mydocs')
" python

Racket

#lang racket

(rename-file-or-directory "input.txt" "output.txt")
(rename-file-or-directory "docs" "mydocs")

;; find the filesystem roots, and pick the first one
(define root (first (filesystem-root-list)))

(rename-file-or-directory (build-path root "input.txt")
                          (build-path root "output.txt"))
(rename-file-or-directory (build-path root "docs")
                          (build-path root "mydocs"))

Raku

(formerly Perl 6)

rename 'input.txt', 'output.txt';
rename 'docs', 'mydocs';
rename '/input.txt', '/output.txt';
rename '/docs', '/mydocs';

Raven

`mv /path/to/file/oldfile /path/to/file/newfile` shell

REALbasic

This should work regardless of what OS it's running under (but untested under Mac OS).

Sub Renamer()
    Dim f As FolderItem, r As FolderItem

    f = GetFolderItem("input.txt")
    'Changing a FolderItem's Name attribute renames the file or directory.
    If f.Exists Then f.Name = "output.txt"
    'Files and directories are handled almost identically in RB.
    f = GetFolderItem("docs")
    If f.Exists Then f.Name = "mydocs"

    'Jump through hoops to find the root directory.
    r = RootDir(GetFolderItem("."))

    f = r.Child("input.txt")
    'Renaming in a different directory identical to renaming in current directory.
    If f.Exists Then f.Name = "output.txt"
    f = r.Child("docs")
    If f.Exists Then f.Name = "mydocs"
End Sub

Function RootDir(what As FolderItem) As FolderItem
    'RB doesn't have an easy way to find the root of the current drive;
    'not an issue under *nix but troublesome under Windows.
    If what.Parent <> Nil Then  'Nil = no parent = root.
        Return RootDir(what.Parent) 'Recursive.
    Else
        Return what
    End If
End Function

REBOL

rename %input.txt %output.txt
rename %docs/ %mydocs/

; Unix. Note that there's no path specification used for the 
; new name. "Rename" is not "move".

rename %/input.txt %output.txt
rename %/docs/ %mydocs/

; DOS/Windows:

rename %/c/input.txt %output.txt
rename %/c/docs/ %mydocs/

; Because REBOL treats data access schemes as uniformly as possible, 
; you can do tricks like this:

rename ftp://username:password@ftp.site.com/www/input.txt %output.txt
rename ftp://username:password@ftp.site.com/www/docs/ %mydocs/

REXX

error messages shown

/*REXX program renames a file & a directory  (in current dir & in root).*/
trace off                              /*suppress error messages, bad RC*/

    do 2                               /* [↓]  perform this code twice. */
    'RENAME' "input.txt  output.txt"   /*rename a particular DOS file.  */
    'MOVE'   "\docs  \mydocs"          /*use (DOS) MOVE to rename a dir.*/
    'CD'     "\"                       /*for 2nd pass, change──►root dir*/
    end   /*2*/
                                       /*stick a fork in it, we're done.*/

error messages suppressed

/*REXX program renames a file & a directory  (in current dir & in root).*/
trace off                              /*suppress error messages, bad RC*/
$ = '2> NUL'                           /*used to suppress error messages*/

  do 2                                 /* [↓]  perform this code twice. */
  'RENAME' "input.txt  output.txt"  $  /*rename a particular DOS file.  */
  'MOVE'   "\docs  \mydocs"         $  /*use (DOS) MOVE to rename a dir.*/
  'CD'     "\"                      $  /*for 2nd pass, change──►root dir*/
  end   /*2*/
                                       /*stick a fork in it, we're done.*/

Ring

  rename("input.txt", "output.txt")
  rename("docs", "mydocs")
  rename("/input.txt", "/output.txt")
  rename("/docs", "/mydocs")

RPL

RPL’s tree file system is made of variables, which can contain either programs or data, and directories. Variables and directories handling features are basic.

Works with: Halcyon Calc version 4.2.7

RPL code	Comment
≪ PATH { HOME } == 1 ROT IFTE → old new here ≪ IF here NOT THEN PATH HOME END IFERR old RCL THEN new CRDIR PURGE ELSE new STO old PURGE END IF here NOT THEN 2 OVER SIZE FOR j DUP j GET EVAL NEXT DROP END ≫ ≫ 'RNAME' STO	RNAME ( ‘old’ ‘new’ boolean -- ) Set here to true if already at root Store arguments Store current path in stack and go to the root Detect if old is a directory by recalling its content If yes, create new then delete old Otherwise, store content in new, then delete old Go back to current directory following the path in stack Forget path

Input:

'Input' 'Output' 1 RNAME
'DOCS' 'MYDOCS' 0 RNAME

The boolean argument indicates if the renaming must be achieved in the current directory (1) or at the root (0).

Ruby

File.rename('input.txt', 'output.txt')
File.rename('/input.txt', '/output.txt')
File.rename('docs', 'mydocs')
File.rename('/docs', '/mydocs')

With 'fileutils' from the standard library: The FileUtils#move method has some more flexibility than the core File#rename method (not really demonstrated here).

require 'fileutils'
moves = { "input.txt" => "output.txt", "/input.txt" => "/output.txt", "docs" => "mydocs","/docs" => "/mydocs"}
moves.each{ |src, dest| FileUtils.move( src, dest, :verbose => true ) }

Run BASIC

RB has no direct command. You Shell out to windows or unix.

a$ = shell$("RENAME input.txt output.txt")
a$ = shell$("RENAME docs mydocs")
a$ = shell$("RENAME \input.txt \output.txt")
a$ = shell$("RENAME \docs \mydocs")

Rust

use std::fs;

fn main() {
    let err = "File move error";
    fs::rename("input.txt", "output.txt").ok().expect(err);
    fs::rename("docs", "mydocs").ok().expect(err);
    fs::rename("/input.txt", "/output.txt").ok().expect(err);
    fs::rename("/docs", "/mydocs").ok().expect(err);
}

S-BASIC

The only operating system for which S-BASIC has been implemented is CP/M, which has no concept of named directories or a root directory. The closest analog to a root directory is drive A:, user 0, which on a normally-configured CP?M system is the active directory on boot-up. Renaming a file in the current active directory is straight-forward:

rename "INPUT.TXT" to "OUTPUT.TXT"

To rename a file in the start-up (some other) directory requires the help of user-written functions which in turn make the appropriate operating system calls through the BDOS jump vector at 0005H:

rem - Set the CP/M user area (0 to 15)
procedure setuser (user = integer)
   var hl, bc, a_psw = integer
   hl = 0
   bc = 20H    rem - BDOS set user function
   a_psw = 0
   call (5H,hl,user,bc,a_psw)
end

rem - Set the logged drive ('A' to 'P')
procedure setdrive (drive = char)
   var hl, de, bc, a_psw = integer
   rem -- make sure drive letter is upper case!
   if drive >= 'a' then drive = drive - 32
   hl = 0
   de = drive - 65
   bc = 0EH    rem - BDOS set drive function
   a_psw = 0
   call (5H,hl,de,bc,a_psw)
end

setuser 0
setdrive 'A'
rename "INPUT.TXT" to "OUTPUT.TXT"

Scala

Library: Scala

Straight forward

import scala.language.implicitConversions
import java.io.File

object Rename0 {
  def main(args: Array[String]) {              // The implicit causes every String to File mapping,
    implicit def file(s: String) = new File(s) // will be converted to new File(String)
    "myfile.txt" renameTo "anotherfile.txt"
    "/tmp/myfile.txt" renameTo "/tmp/anotherfile.txt"
    "mydir" renameTo "anotherdir"
    "/tmp/mydir" renameTo "/tmp/anotherdir"
  }
}

Alternative

object Rename1 {
  def main(args: Array[String]) {
    List(("myfile.txt", "anotherfile.txt"),("/tmp/myfile.txt", "/tmp/anotherfile.txt"),
         ("mydir", "anotherdir"),("/tmp/mydir", "/tmp/anotherdir")).foreach{ case (oldf, newf) ⇒
      new java.io.File(oldf) renameTo new java.io.File(newf)
    }
  }
}

Scheme

Works with: Chicken Scheme

Works with: Guile

(rename-file "input.txt" "output.txt")
(rename-file "docs" "mydocs")
(rename-file "/input.txt" "/output.txt")
(rename-file "/docs" "/mydocs")

Seed7

The library osfiles.s7i defines the function moveFile, which renames / moves a file. Seed7 uses a standard path representation to make paths operating system independent. In the standard path representation a / is used as path delimiter and drive letters like C: must be written as /c instead. Creating files and directories in a file system root may need privileges, so the program may fail, when it is started by a normal user.

$ include "seed7_05.s7i";
  include "osfiles.s7i";

const proc: main is func
  begin
    moveFile("input.txt", "output.txt");
    moveFile("docs", "mydocs");
    moveFile("/input.txt", "/output.txt");
    moveFile("/docs", "/mydocs");
  end func;

Under Windows each filesystem has its own root. Therefore you need to replace "/input.txt", "/output.txt", "/docs" and "/mydocs" with "/c/input.txt", "/c/output.txt", "/c/docs" and "/c/mydocs".

Sidef

# Here
File.rename('input.txt', 'output.txt');
File.rename('docs',      'mydocs');

# Root dir
File.rename(Dir.root + %f'input.txt', Dir.root + %f'output.txt');
File.rename(Dir.root + %f'docs',      Dir.root + %f'mydocs');

Slate

(File newNamed: 'input.txt') renameTo: 'output.txt'.
(File newNamed: '/input.txt') renameTo: '/output.txt'.
(Directory newNamed: 'docs') renameTo: 'mydocs'.
(Directory newNamed: '/docs') renameTo: '/mydocs'.

Smalltalk

Works with: GNU Smalltalk

File rename: 'input.txt' to: 'output.txt'.
File rename: 'docs' to: 'mydocs'.
"as for other example, this works on systems
 where the root is / ..."
File rename: '/input.txt' to: '/output.txt'.
File rename: '/docs' to: '/mydocs'

Works with: Smalltalk/X

Works with: VisualWorks Smalltalk

'input.txt' asFilename renameTo: 'output.txt'.
'docs' asFilename renameTo: 'mydocs'.
'/input.txt' asFilename renameTo: '/output.txt'.
'/docs' asFilename renameTo: '/mydocs'

Works with: Pharo Smalltalk

'input.txt' asFileReference renameTo: 'output.txt'.
'docs' asFileReference renameTo: 'mydocs'.
'/input.txt' asFileReference renameTo: '/output.txt'.
'/docs' asFileReference renameTo: '/mydocs'

Standard ML

OS.FileSys.rename {old = "input.txt", new = "output.txt"};
OS.FileSys.rename {old = "docs", new = "mydocs"};
OS.FileSys.rename {old = "/input.txt", new = "/output.txt"};
OS.FileSys.rename {old = "/docs", new = "/mydocs"};

Stata

Use a shell command. The following works on Windows, there are similar commands on other operating systems.

!ren input.txt output.txt
!ren docs mydocs

Tcl

Assuming that the Bash example shows what is actually meant with this task (one file and one directory here, one file and one directory in the root) and further assuming that this is supposed to be generic (i.e. OS agnostic):

file rename inputs.txt output.txt
file rename docs mydocs
 
file rename [file nativename /inputs.txt] [file nativename /output.txt]
file rename [file nativename /docs] [file nativename /mydocs]

Without the need to work on unusual platforms like Mac OS 9, the code could be just:

file rename inputs.txt output.txt
file rename docs mydocs
 
file rename /inputs.txt /output.txt
file rename /docs /mydocs

Toka

needs shell
" input.txt"  " output.txt"  rename
" /input.txt"  " /output.txt"  rename

" docs"  " mydocs"  rename
" /docs"  " /mydocs"  rename

TorqueScript

fileCopy("Input.txt", "Output.txt");
fileDelete("Input.txt");

for(%File = FindFirstFile("Path/*.*"); %File !$= ""; %File = FindNextFile("Path/*.*"))
{
	fileCopy(%File, "OtherPath/" @ %File);
	fileDelete(%File);
}

TUSCRIPT

$$ MODE TUSCRIPT
- rename file
ERROR/STOP RENAME ("input.txt","output.txt")
- rename directory
ERROR/STOP RENAME ("docs","mydocs",-std-)

TXR

TXR works with native paths.

(rename-path "input.txt" "output.txt")
;; Windows (MinGW based port)
(rename-path "C:\\input.txt" "C:\\output.txt")
;; Unix; Windows (Cygwin port)
(rename-path "/input.txt" "/output.txt"))

Directories are renamed the same way; input.txt could be a directory.

UNIX Shell

mv input.txt output.txt
mv /input.txt /output.txt
mv docs mydocs
mv /docs /mydocs

Vedit macro language

Vedit allows using either '\' or '/' as directory separator character, it is automatically converted to the one used by the operating system.

// In current directory
File_Rename("input.txt", "output.txt")
File_Rename("docs", "mydocs")

// In the root directory
File_Rename("/input.txt", "/output.txt")
File_Rename("/docs", "/mydocs")

Visual Basic .NET

Platform: .NET

Works with: Visual Basic .NET version 9.0+

'Current Directory
IO.Directory.Move("docs", "mydocs")
IO.File.Move("input.txt", "output.txt")

'Root
IO.Directory.Move("\docs", "\mydocs")
IO.File.Move("\input.txt", "\output.txt")

'Root, platform independent
IO.Directory.Move(IO.Path.DirectorySeparatorChar & "docs", _
 IO.Path.DirectorySeparatorChar & "mydocs")
IO.File.Move(IO.Path.DirectorySeparatorChar & "input.txt", _
  IO.Path.DirectorySeparatorChar & "output.txt")

Wren

Library: Wren-ioutil

Wren-cli does not currently have the ability to rename directories, just files.

import "./ioutil" for FileUtil

FileUtil.move("input.txt", "output.txt")
FileUtil.move("/input.txt", "/output.txt")

Yabasic

if peek$("os") = "windows" then
    slash$ = "\\" : com$ = "ren "
else
    slash$ = "/" : com$ = "mv "
end if

system(com$ + "input.txt output.txt")
system(com$ + "docs mydocs")
system(com$ + slash$ + "input.txt " + slash$ + "output.txt")
system(com$ + slash$ + "docs " + slash$ + "mydocs")

Yorick

Translation of: UNIX Shell

rename, "input.txt", "output.txt";
rename, "/input.txt", "/output.txt";
rename, "docs", "mydocs";
rename, "/docs", "/mydocs";

zkl

Tested on Linux and Windows 10.

Output:

ls -ld input.txt docs output.txt mydocs
ls: cannot access 'output.txt': No such file or directory
ls: cannot access 'mydocs': No such file or directory
drwxr-xr-x 2 craigd craigd 4096 Aug 10 16:24 docs
-rw-r--r-- 1 craigd craigd    0 Aug 10 16:24 input.txt
$ zkl
zkl: File.rename("input.txt","output.txt")
True
zkl: File.rename("docs","mydocs")
True
zkl: ^D
$ ls -ld input.txt docs output.txt mydocs
ls: cannot access 'input.txt': No such file or directory
ls: cannot access 'docs': No such file or directory
drwxr-xr-x 2 craigd craigd 4096 Aug 10 16:24 mydocs
-rw-r--r-- 1 craigd craigd    0 Aug 10 16:24 output.txt

If don't have permissions (amongst other things):

zkl: File.rename("/input.txt","/output.txt")
Exception thrown: IOError(rename(/input.txt,/output.txt): Permission denied)