code equivalences

nil

#nil

nil

nil

f

Nil

None

nil

nil

nil

null

t nil

#t #f

t nil

true false

t f

True False

True False

1 0

true false

true false

true false

0 1

0 1

true false

true false

#<unspecified>
#<eof>

undefined

thisContext

__builtins__
__doc__
__file__
__loader__
__name__
__package__

this
thisFunction

_G

_G

arguments

'heyo

'heyo

'heyo

#heyo

heyo

heyo

\heyo

:heyo

Symbol("heyo")

"Foo"

"Foo"

"Foo"

'Foo'

"Foo"

"Foo"

"Foo"

"Foo"

"Foo"

"Foo"

"Foo"

"Foo"

"Foo"

"Foo"

"Foo"

#\F

#\F

?F

$F

CHAR: F

$F

'F'

(code-char 10084)

(integer->char 10084)

10084

Character codePoint: 10084

10084

"\c[10084]"

chr(10084)

"u2764"

10048.asAscii

"u{2764}"

#\HEAVY_BLACK_HEART

(use-modules (ice-9 unicode))
(formal-name->char "HEAVY BLACK HEART")

?\N{HEAVY BLACK HEART}

(UnicodeCharacterData named: 'HEAVY BLACK HEART') character

CHAR: heavy-black-heart

"\c[heavy black heart]"

\N{HEAVY BLACK HEART}

4/3

4/3

4/3

4/3

4/3

import fractions
fractions.Fraction(4, 3)

4/3

'(1 2 3)

'(1 2 3)

'(1 2 3)

#(1 2 3)

{ 1 2 3 }

[1, 2, 3]

[1, 2, 3]

{1 2 3}

[1, 2, 3]

{1, 2, 3}

[1 2 3]

(1 2 3)

1 2 3

[1, 2, 3]

'(1 2 3)

'(1 2 3)

'(1 2 3)

| linkedList |
linkedList := LinkedList new.
linkedList add: 1.
linkedList add: 2.
linkedList add: 3.

L{ 1 2 3 }

(1, 2, 3)

from collections import deque
deque([1, 2, 3])

List.newUsing([1, 2, 3])

#(1 2 3)

#(1 2 3)

[1 2 3]

#(1 2 3)

{ 1 2 3 }

[1, 2, 3]

[1, 2, 3]

{1 2 3}

[1, 2, 3]

{1, 2, 3}

[1 2 3]

(1 2 3)

1 2 3

[1, 2, 3]

; Do something.

; Do something.

; Do something.

"Do something."

! Do something.

# Do something.

# Do something.

;# Do something.

// Do something.

-- Do something.

; Do something.

# Do something.

# Do something.

// Do something.

// Do something.

#| hello line 1
hello line 2 |#

#! hello line 1
hello line 2 !#

"hello line 1
hello line 2"

USE: multiline
/* hello line 1
hello line 2 */

#`( hello line 1
hello line 2 )

"""hello line 1
hello line 2"""

/* hello line 1
hello line 2 */

--[[ hello line 1
hello line 2 ]]

/* hello line 1
hello line 2 */

/* hello line 1
hello line 2 */

(* (+ 1 3) 4)

(* (+ 1 3) 4)

(* (+ 1 3) 4)

1 + 3 * 4.

1 3 + 4 *

(1 + 3) * 4;

(1 + 3) * 4

expr {(1 + 3) * 4}

1 + 3 * 4

(1 + 3) * 4

(* (+ 1 3) 4)

$(((1 + 3) * 4))

math '(1 + 3) * 4'

((1 + 3) * 4)

((1 + 3) * 4)

(defvar foo)

(define foo)

(defvar foo)

| foo |

SYMBOL: foo

our $foo;

global foo

set foo ""

~foo;

local foo

(var foo nil)

foo=

set foo

var foo

let foo;

(defparameter foo 3)

(define foo 3)

(defvar foo 3)

| foo |
foo := 3.

SYMBOL: foo 3 foo set

our $foo = 3;

global foo
foo = 3

set foo 3

~foo = 3;

local foo = 3

(var foo 3)

foo=3

set foo 3

var foo = 3;

let foo = 3;

(defvar foo 3)

(define foo 3)

(defvar foo 3)

INITIALIZED-SYMBOL: foo [ 3 ]

if {![info exists foo]} { set foo 3 }

~foo = ~foo ? 3;

if not set -q foo; set foo 3; end

(lambda (x y) (+ x y))

(lambda (x y) (+ x y))

(lambda (x y) (+ x y))

[ :x :y | x + y ]

[ + ]

sub ($x, $y) { $x + $y }

lambda x, y: x + y

{ | x y | x + y; }

function (x, y) x + y end

(fn [x y] (+ x y))

| x, y | { x + y }

(defun plus-3 (x) (+ x 3))

(define (plus-3 x) (+ x 3))

(defun plus-3 (x) (+ x 3))

| plus_3 |
plus_3 := [ :x | x + 3 ]

: plus-3 ( x -- y ) 3 + ;

sub plus-three($x) { return $x + 3; }

def plus_3(x): return x + 3

proc plus_3 {x} { return [expr {$x + 3}] }

~plus_3 = { | x | x + 3; };

function plus_3(x) x + 3 end

(fn plus-3 [x] (+ x 3))

plus_3() { echo $(($1 + 3)); }

function plus_3; math $x + 3; end

fn plus_3() { x + 3 }

(defun print-each (&rest x)
  (mapcar 'print x))

(define (print-each . x)
  (for-each write x))

(defun print-each (&rest x)
  (mapcar 'print x))

sub print-each(*@x) {
  @x.map: &say
}

def print_each(*x):
  print(*x, sep='n')

proc print-each args {
  foreach arg $args {
    puts $arg
  }
}

~print_each = { | ... x |
  x.do(_.postln)
};

function print_each(...)
  for _, v in ipairs({...}) do
    print(v)
  end
end

(fn print-each [...]
  (each [_ v (ipairs [...])] (print v)))

print_each() {
  for arg in "$@"
    do echo "$arg"
  done
}

function print-each
  for arg in $argv
    echo $arg
  end
end

function print_each() {
  Array.from(arguments)
    .forEach(console.log);
}

(my-func 1 2)

(my-func 1 2)

(my-func 1 2)

my_func value: 1 value: 2.

1 2 my-func

my-func(1, 2)

my_func(1, 2)

my_func 1 2

my_func.value(1, 2);

my_func(1, 2)

(my-func 1 2)

my_func 1 2

my_func 1 2

my_func(1, 2)

my_func(1, 2)

(funcall my-func 1 2)

(my-func 1 2)

(funcall my-func 1 2)

(apply #'my-func '(1 2))

(apply my-func '(1 2))

(apply #'my-func '(1 2))

(my-func (table.unpack [1 2]))

(princ "Hello.")

(display "Hello.")

(message "Hello.")

Transcript show: 'Hello.'.

"Hello." write

"Hello.".print;

print("Hello.", end="")

puts -nonewline Hello.

"Hello.".post;

io.write("Hello.")

(io.write "Hello.")

echo -n "Hello."

echo -n "Hello."

print!("Hello.");

(format t "~A~%" "Hello.")

(display "Hello.")
(newline)

(message "%s\n" "Hello.")

Transcript show: 'Hello.'; cr.

"Hello." print

"Hello.".say;

print("Hello.")

puts "Hello."

"Hello.".postln;

print("Hello.")

(print "Hello.")

echo "Hello."

echo "Hello."

println!("Hello.")

(if some-test then-do-this else-this)

(if some-test then-do-this else-this)

(if some-test then-do-this else-this)

someTest ifTrue: [ thenDoThis ]; ifFalse: [ elseThis ].

some-test [ then-do-this ] [ else-this ] if

if some-test { then-do-this } else { else-this }

if some_test:
  then_do_this
else:
  else_this

if [some_test] { do_this } else { else_this }

if(some_test, { then_do_this }, { else_this })

if some_test then then_do_this else else_this end

(if some-test then-do-this else-this)

if some_test; then then_do_this; else else_this; fi

if some_test; then_do_this; else; else_this; end

if some_test {
  do_this
} else {
  else_this
}

(type-of datum)

(use-modules (oop goops))
(class-of datum)

(type-of datum)

datum class.

datum class-of

datum.WHAT

type(datum)

::tcl::unsupported::representation $datum

datum.class

type(datum)

(type datum)

typeof(datum)

(format "~S" obj)

(format #f "~S" obj)

(format "%s" obj)

obj storeString.

"%u" sprintf

$obj.raku

repr(obj)

obj.cs;

tostring(obj)

(fennel.view obj)

JSON.stringify(obj)

format!("{:?}", obj)

(print obj)

(write obj)

(message (format "%s" obj))

Transcript show: obj.

obj .

$obj.raku.say

print(obj)

obj.postcs;

print(obj)

(print (fennel.view obj))

echo $obj

echo $obj

console.log(obj)

println!("{:?}, obj")

(read-line)

(use-modules (ice-9 rdelim))
(read-line)

(read-string "")

SpRequestTextDialog new openModal.

readln

prompt()

input()

gets stdin

EZText(action:{ | widget | f = widget.value; widget.window.close; });

io.read()

(io.read)

read var

read

prompt()

sb-ext:double-float-negative-infinity

+inf.0

Float infinity.

1/0.

Inf

expr Inf

inf

(sb-int:set-floating-point-modes :traps nil)
(/ 0d0 0d0)

+nan.0

-0.0e+NaN

Float nan.

pi

(acos -1)

float-pi

Float pi.

pi

pi

math pi

(random n)

(random n)

(random n)

n atRandom - 1

n random

n.rand.Int

from random import randint
randint(0, n - 1)

expr { int(rand() * n) }

n.rand

require("math")
math.random(0, n - 1)

(local math (require :math))
(math.random 0 (- n 1))

$(($RANDOM % $n))

random 0 (math $n - 1)

Math.floor(Math.random() * n)

(random n)

(random n)

(random* n)

Random new nextBetween: 0.0 and: n

n random

n.rand

from random import random
random() * n

expr { rand() * n }

n.rand

Math.random() * n

(length my-sequence)

(length my-sequence)

(length my-sequence)

my_array size

my-array length

@my-array.elems

len(my_list)

llength $my_list

my_array.size

#my_table

(length my-table)

${#my_list[@]}

count $my_list

my_array.length

my_array.len()

(first my-list)

(car my-list)

(car my-list)

my_array first

my-array first

@my-array.first

my_list[0]

lindex $my_list 0

my_array.first

my_table[1]

(. my-table 1)

${my_list[0]}

$my_list[1]

my_array[0]

my_array[0]

(second my-list)

(list-ref my-list 1)

(cadr my-list)

my_array second

my-array second

@my-array[1]

my_list[1]

lindex $my_list 1

my_array[1]

my_table[2]

(. my-table 2)

${my_list[2]}

$my_list[2]

my_array[1]

my_array[1]

(car (last my-list))

(car (last-pair my-list))

(car (last my-list))

my_array last

my-array last

@my-array.tail

my_list[-1]

my_array.last

my_table[#my_table]

(. my-table (length my-table))

${my_list[-1]}

$my_list[-1]

my_array[my_array.length-1]

(nth n my-list)

(list-ref my-list n)

(nth n my-list)

my_array at: n

n my-array nth

@my-array[n]

my_list[n]

lindex $my_list n

my_array[n]

my_table[n]

(. my-table n)

${my_list[n]}

$my_list[n]

my_array[n]

my_array[n]

(subseq my-list 0 n)

(list-head my-list n)

(subseq my-list 0 n)

myList first: n.

my-array n head

@my-array.head(n)

my_list[:n]

my_array.keep(n)

table.unpack(my_table, 1, n)

(table.unpack my-table 1 n)

"${my_array[@]:0:$n}"

$my_list[..$n]

(subseq my-list n)

(list-tail my-list n)

(subseq my-list n)

myList allButFirst: n

my-array n tail

@my-array[n..*]

my_list[n:]

my_array[n..]

table.unpack(my_table, n+1)

(table.unpack my-table (+ n 1))

$my_list[(math $n + 1)..]

(last my-list n)

(list-tail my-list (- (length my-list) n))

(last my-list n)

myList last: n

my-array n tail*

@my-array.tail(n)

my_list[-n:]

my_array.keep(-n)

table.unpack(my_table, #my_table-(n-1))

(table.unpack my-table (- (length my-table) (- n 1)))

$my_list[(math - $n)..]

(butlast my-list n)

(list-head my-list (- (length my-list) n))

(butlast my-list n)

myList allButLast: n

my-array n head*

@my-array.head(*-$n)

my_list[:-n]

my_array.drop(-n)

table.unpack(my_table, 1, #my_table-n)

(table.unpack my-table 1 (- (length my-table) n))

$my_list[..(math "-1 * $n - 1")]

(subseq my-seq start end)

(list-head (list-tail my-list start) (- end start))

(subseq my-seq start end)

mySeq copyFrom: start to: end

start end my-array subseq

@my-array[start..end-1]

my_list[start:end]

my_array[start..end-1]

table.unpack(my_table, start, end)

(table.unpack my-table start end)

$my_list[start..end]

(remove-if-not pred my-list)

(filter pred my-list)

(cl-remove-if-not pred my-list)

myList select: [ :x | x pred. ].

my-array pred filter

@my-array.grep(pred)

[i for i in my_list if pred(i)]

my_array.select(pred)

(remove-if pred my-list)

(filter (lambda (x) (not (pred x))) my-list)

(cl-remove-if pred my-list)

myList reject: [ :x | x pred. ].

my-array pred reject

[i for i in my_list if not pred(i)]

my_array.reject(pred)

(remove item my-list)

(use-modules (srfi srfi-1))
(remove (lambda (i) (eq? i item)) my-list)

(cl-remove item my-list)

item my-sequence remove

[i for i in my_list if i != item]

my_array.removeEvery([item])

(find item my-list)

(member item my-list)

(member item my-list)

myList includes: item.

item my-array member?

$item (elem) @my-array

item in my_list

my_array.includes(item)

contains item $my_list

(position item my-list)

(list-index my-list item)

(cl-position item my-list)

myList indexOf: item.

item my-array index

my_list.index(item)

my_array.indexOf(item)

contains --index item $my_list

(find-if pred my-list)

(find pred my-list)

(cl-find-if pred my-list)

myList detect: [ :x | x pred. ].

my-array pred find

@my-array.first(pred)

my_array.detect(pred)

(position-if pred my-list)

(list-index pred my-list)

(cl-find-if pred my-list)

my-array pred find

@my-array.first(pred, :k)

my_array.detectIndex(pred)

(every pred my-list)

(every pred my-list)

(cl-every pred my-list)

my-sequence pred all?

my_array.every(pred)

(count item my-list)

(count (lambda (x) (equal? x item)) my-list)

(cl-count item my-list)

myList occurrencesOf: item

my-sequence [ item = ] count

my_list.count(item)

my_array.occurrencesOf(item)

(count-if pred my-list)

(count pred my-list)

(cl-count-if pred my-list)

myList count: pred

my-sequence pred count

len(list(filter(pred, my_list)))

my_array.count(pred)

(mapcar func my-list)

(map func my-list)

(mapcar func my-list)

myList collect: [ :x | func ].

my-array func map

@my-array.map(func)

my_array.collect(func)

(reduce func my-list)

(reduce func identity my-list)

(seq-reduce func my-list identity)

myList inject: identity into: func

my-sequence identity func reduce

reduce &func, @my-array

my_array.reduce(func)

(intersection list-1 list-2)

(use-modules (srfi srfi-1))
(lset-intersection = list-1 list-2)

(intersection list-1 list-2)

array-1 array-2 intersect

array1.sect(array2)

(set-difference list-1 list-2)

(use-modules (srfi srfi-1))
(lset-difference = list-1 list-2)

(set-difference list-1 list-2)

list1 difference: list2

sequence-1 sequence-2 diff

array1.difference(array2)

(union list-1 list-2)

(use-modules (srfi srfi-1))
(lset-union equal? '(1 2 3) '(3 4 5))

(union list-1 list-2)

list1 union: list2

sequence-1 sequence-2 union

array1.union(array2)

(remove-duplicates my-list)

(delete-duplicates my-list)

(cl-remove-duplicates my-list)

my-seq members

my_array.asSet.asArray

(remove-duplicates my-list :test pred)

(delete-duplicates my-list equal?)

(cl-remove-duplicates my-list :test pred)

[let
    { } :> seen!
    my-seq [
        [ [ comparison-word ] curry seen swap find drop ]
        [ seen swap suffix seen! ] bi
    ] reject
]

(reverse my-list)

(reverse my-list)

(reverse my-list)

myArray reverse

my-sequence reverse

@my-array.reverse

my_list.reverse()
my_list

my_array.reverse

my_array.toReversed()

(sort my-list #'<)

(sort my-list <)

(sort my-list #'<)

myList sorted

my-sequence sort

my_array.sort

my_array.toSorted(pred)

(sort my-list pred)

(sort my-list pred)

(sort my-list pred)

myList sorted: pred

my-sequence pred sort-by

my_array.sort(pred)

my_array.toSorted(pred)

(alexandria:random-elt my-list)

(list-ref my-list (random (length my-list)))

my-array random

@my-array.pick

random choice $my_array

(length "🤦🏼‍♂️") ; 5

(string-length "🤦🏼‍♂️") ; 5

(length "🤦🏼‍♂️") ; 5

'🤦🏼‍♂️' size. "5"

"🤦🏼‍♂️" length ! 5
"🤦🏼‍♂️" >graphemes length ! 1

"🤦🏼‍♂️".elems # 1

len("🤦🏼‍♂️") # 5

string length "🤦🏼‍♂️" ;# 7

"🤦🏼‍♂️".size // 17

string.len("🤦🏼‍♂️") -- 17

(length "🤦🏼‍♂️") ; 17

foo='🤦🏼‍♂️'; echo ${#foo} # 5

string length "🤦🏼‍♂️" # 5

"🤦🏼‍♂️".length // 7

"🤦🏼‍♂️".len() // 17

(concatenate 'string "foo" "bar")

(string-append "foo" "bar")

(concat "foo" "bar")

'foo', 'bar'

"foo" "bar" append

"foo" ~ "bar"

"foo" + "bar"

"foo" ++ "bar"

(.. "foo" "bar")

"foo""bar"

"foo""bar"

(subseq "foo bar" 0 3)

(substring "foo bar" 0 3)

(substring "foo bar" 0 3)

'foo bar' copyFrom: 1 to: 3.

0 3 "foo bar" subseq

substr("foo bar", 0, 3)

"foo bar"[0:3]

"foo bar"[0..2]

(string.sub "foo bar" 1 3)

string sub -s 1 -e 4 "foo bar"

(string-downcase "FOO")

(string-downcase "FOO")

(downcase "FOO")

'FOO' asLowercase

"FOO" >lower

"FOO".lc

"FOO".lower()

string tolower "FOO"

"FOO".toLower

string.lower("FOO")

(string.lower "FOO")

echo FOO | tr '[:upper:]' '[:lower:]'

string lower FOO

"FOO".toLowerCase()

(make-hash-table)

(make-hash-table)

(make-hash-table)

Dictionary new

8 <hashtable>

Hash()

dict create

Dictionary()

{}

declare -A my_hash

#s(hash-table data (foo 1 bar 2))

H{ { "foo" 1 } { "bar" 2 } }

{foo => 1, bar => 2}

(foo: 1, bar: 2)

{}

{:foo 1 :bar 2}

declare -A my_hash=( [foo]=1 [bar]=2 )

(gethash "key" hash)

(hash-ref hash "key")

(gethash "key" hash)

myDict at: key

hash "key" at

%hash{"key"}

dict get $hash "key"

dict.at(key)

(. dict key)

${hash[key]}

(setf (gethash "key" hash) 9)

(hash-set! hash "key" 9)

(puthash "key" 9 hash)

myDict at: 'key' put: 9

9 "key" hash set-at

%hash{"key"} = 9;

dict set hash key

dict.put(key, 9)

(set (. dict key) 9)

hash[key]=9

(loop for key being the hash-keys of hash collect key)

(hash-map->list (lambda (key value) key) hash)

(hash-table-keys hash)

myDict keys

hash keys

%hash.keys;

dict keys $hash

dict.keys

${!hash[@]}

(defpackage #:my-package ...)

(define-module (my-module) ...)

"my-vocab" create-vocab

unit module MyModule;

Environment()

*package*

(current-module)

current-vocab

currentEnvironment

(in-package #:my-package)

(set-current-module (resolve-module '(my-module)))

IN: my-vocab

env.push

(use-package #:other-package)

(use-modules (my-module) ...)

USE: other-vocab

use MyModule;

env.use(func)

my-module:my-thing

MyModule::my-thing

env.my_thing

(defmacro my-macro (arg-1 arg-2)
  `(do-thing ,arg-1 ,arg-2))

(define-syntax my-macro
  (syntax-rules ()
    ((_ arg-1 arg-2)
     (do-thing arg-1 arg-2))))

(defmacro my-macro (arg-1 arg-2)
  `(do-thing ,arg-1 ,arg-2))

macro my-macro($arg-1, $arg-2) {
  quasi { do-thing({{{ $arg-1 }}, {{{ $arg-2 }}) }
}

(macro my-macro [arg-1 arg-2]
  `(do-thing ,arg-1 ,arg-2))

(documentation thing object-type)

(procedure-documentation thing)

(documentation thing)

thing.WHY;

(apropos "")

(apropos ".*")

(apropos query)

(apropos query)

(apropos query)

(describe obj)

(inspect obj)

,inspect obj

obj inspect

(closer-mop:class-slots (class-of obj)) ; get slot definition objects
(closer-mop:slot-definition-name slot) ; get a slot's name

obj class instanceVariables

obj class-of all-slots

obj.^methods

dir(obj)

(closer-mop:specializer-direct-methods (class-of obj))

obj class methods

obj.^methods

dir(obj)

obj.class.methods

• StumpWM (WM)
• McCLIM (UI toolkit)
• OM# (music)
• Incudine (music)
• Lem (editor)
• Kandria (game)

• Guix (OS/package manager)

• Emacs (editor)
• Magit (version control UI)
• Org-Mode (publishing/organizing)

• Glamorous Toolkit (IDE)

• Factor (language)

• Comma (IDE)

• NumPy/SciPy (math)
• Deluge (P2P)
• Nicotine+ (P2P)
• beets (music library manager)
• borg (backups)
• yt-dlp (media downloader)
• gallery-dl (media downloader)

• Tk (UI toolkit)
• Expect (automation)
• Eggdrop (IRC bot)
• Pure Data (music)

• SuperCollider (synthesis and sequencing)

• LÖVE (game engine)

• Fennel (language)

• SysVinit (init system)

• Fisher (package manager)

• Node.js (framework)
• VSCode (editor)
• Electron (framework)