API

• base64

  • base64/decode
  • base64/decode-url
  • base64/encode
  • base64/encode-url

• core

  • %
  • *
  • **
  • *assert*
  • *build-mode*
  • *file*
  • *hierarchy*
  • *ns*
  • *program*
  • +
  • -
  • ->
  • ->>
  • /
  • <
  • <=
  • <=>
  • =
  • >
  • >=
  • >=<
  • NAN
  • NaN?
  • abs
  • aclone
  • add-watch
  • all?
  • ancestors
  • and
  • apply
  • argv
  • array-map
  • as->
  • assert
  • assoc
  • assoc!
  • assoc-in
  • associative?
  • atom
  • atom?
  • binding
  • bit-and
  • bit-clear
  • bit-flip
  • bit-not
  • bit-or
  • bit-set
  • bit-shift-left
  • bit-shift-right
  • bit-test
  • bit-xor
  • boolean
  • boolean?
  • butlast
  • byte
  • case
  • cat
  • catch
  • char
  • char?
  • coerce-in
  • coll?
  • comment
  • comp
  • compact
  • compare
  • compile
  • complement
  • completing
  • concat
  • cond
  • cond->
  • cond->>
  • condp
  • conj
  • conj!
  • cons
  • constantly
  • contains-value?
  • contains?
  • count
  • counted?
  • csv-seq
  • cycle
  • dec
  • declare
  • dedupe
  • deep-merge
  • def
  • def-
  • defexception
  • defexception*
  • definterface
  • definterface*
  • defmacro
  • defmacro-
  • defmethod
  • defmulti
  • defn
  • defn-
  • defprotocol
  • defrecord
  • defstruct
  • defstruct*
  • deftype
  • delay
  • delay?
  • deref
  • derive
  • descendants
  • difference
  • disj
  • disj!
  • dissoc
  • dissoc!
  • dissoc-in
  • distinct
  • do
  • doall
  • dofor
  • dorun
  • doseq
  • dotimes
  • doto
  • double
  • double?
  • drop
  • drop-last
  • drop-while
  • empty?
  • eval
  • even?
  • every?
  • ex-cause
  • ex-data
  • ex-info
  • ex-message
  • extend-protocol
  • extend-type
  • extends?
  • extreme
  • false?
  • ffirst
  • file-seq
  • filter
  • finally
  • find
  • find-hierarchy-method
  • find-index
  • first
  • flatten
  • float
  • float?
  • fn
  • fn?
  • fnil
  • for
  • force
  • foreach
  • format
  • frequencies
  • full-name
  • function?
  • gensym
  • get
  • get-in
  • get-validator
  • group-by
  • hash-map
  • hash-map?
  • hash-set
  • id
  • identical?
  • identity
  • if
  • if-let
  • if-not
  • if-some
  • inc
  • indexed?
  • inf?
  • int?
  • integer?
  • interleave
  • interpose
  • intersection
  • into
  • invert
  • isa?
  • iterate
  • iteration
  • juxt
  • keep
  • keep-indexed
  • keys
  • keyword
  • keyword?
  • kvs
  • last
  • lazy-cat
  • lazy-seq
  • let
  • letfn
  • line-seq
  • list
  • list?
  • loop
  • macroexpand
  • macroexpand-1
  • make-hierarchy
  • map
  • map-indexed
  • map?
  • mapcat
  • max
  • max-key
  • mean
  • median
  • memoize
  • memoize-lru
  • merge
  • merge-with
  • meta
  • min
  • min-key
  • name
  • namespace
  • nan?
  • neg?
  • next
  • nfirst
  • nil?
  • nnext
  • not
  • not-any?
  • not-empty
  • not-every?
  • not=
  • ns
  • number?
  • object-array
  • odd?
  • one?
  • or
  • pairs
  • parents
  • parse-boolean
  • parse-double
  • parse-long
  • partial
  • partition
  • partition-all
  • partition-by
  • peek
  • persistent
  • persistent!
  • phel->php
  • php->phel
  • php-array-to-map
  • php-array?
  • php-associative-array
  • php-indexed-array
  • php-object?
  • php-resource?
  • pop
  • pop!
  • pos?
  • print
  • print-str
  • printf
  • println
  • protocol-type-key
  • push
  • put
  • put-in
  • quote
  • rand
  • rand-int
  • rand-nth
  • random-uuid
  • range
  • re-find
  • re-matches
  • re-pattern
  • re-seq
  • read-file-lazy
  • read-string
  • realized?
  • recur
  • reduce
  • reduced
  • reduced?
  • reify
  • remove
  • remove-watch
  • rename-keys
  • repeat
  • repeatedly
  • reset!
  • resolve
  • rest
  • reverse
  • run!
  • satisfies?
  • second
  • select-keys
  • seq
  • seq?
  • sequence
  • set
  • set!
  • set-meta!
  • set-validator!
  • set-var
  • set?
  • shuffle
  • slice
  • slurp
  • some
  • some->
  • some->>
  • some-fn
  • some?
  • sort
  • sort-by
  • sorted-map
  • sorted-map-by
  • sorted-set
  • sorted-set-by
  • sorted?
  • spit
  • split-at
  • split-with
  • str
  • str-contains?
  • string?
  • struct?
  • subset?
  • sum
  • superset?
  • swap!
  • symbol
  • symbol?
  • symmetric-difference
  • take
  • take-last
  • take-nth
  • take-while
  • throw
  • time
  • to-array
  • to-php-array
  • transduce
  • transient
  • tree-seq
  • true?
  • truthy?
  • try
  • type
  • underive
  • union
  • unquote
  • unquote-splicing
  • unreduced
  • unset
  • unset-in
  • update
  • update-in
  • update-keys
  • update-vals
  • vals
  • values
  • var
  • var?
  • vary-meta
  • vec
  • vector
  • vector?
  • volatile!
  • volatile?
  • vreset!
  • vswap!
  • when
  • when-first
  • when-let
  • when-not
  • when-some
  • with-meta
  • with-output-buffer
  • zero?
  • zipcoll
  • zipmap

• debug

  • debug/add-tap
  • debug/dbg
  • debug/dotrace
  • debug/remove-tap
  • debug/reset-taps!
  • debug/reset-trace-state!
  • debug/set-trace-id-padding!
  • debug/spy
  • debug/tap
  • debug/tap>

• html

  • html/doctype
  • html/escape-html
  • html/html
  • html/raw-string
  • html/raw-string?

• http

  • http/create-response-from-map
  • http/create-response-from-string
  • http/emit-response
  • http/files-from-globals
  • http/headers-from-server
  • http/request
  • http/request-from-globals
  • http/request-from-globals-args
  • http/request-from-map
  • http/request?
  • http/response
  • http/response-from-map
  • http/response-from-string
  • http/response?
  • http/uploaded-file
  • http/uploaded-file?
  • http/uri
  • http/uri-from-globals
  • http/uri-from-string
  • http/uri?

• json

  • json/decode
  • json/decode-value
  • json/encode
  • json/encode-value
  • json/valid-key?

• mock

  • mock/call-count
  • mock/called-once?
  • mock/called-times?
  • mock/called-with?
  • mock/called?
  • mock/calls
  • mock/clear-all-mocks!
  • mock/first-call
  • mock/last-call
  • mock/mock
  • mock/mock-fn
  • mock/mock-returning
  • mock/mock-throwing
  • mock/mock?
  • mock/never-called?
  • mock/reset-mock!
  • mock/spy
  • mock/with-mock-wrapper
  • mock/with-mocks

• php

  • php/->
  • php/::
  • php/aget
  • php/aget-in
  • php/apush
  • php/apush-in
  • php/aset
  • php/aset-in
  • php/aunset
  • php/aunset-in
  • php/new
  • php/oset

• repl

  • repl/apropos
  • repl/build-facade
  • repl/compile-str
  • repl/dir
  • repl/doc
  • repl/eval-capturing
  • repl/eval-str
  • repl/find-fn
  • repl/get-source-code
  • repl/get-symbol-info
  • repl/load-file
  • repl/loaded-namespaces
  • repl/macroexpand
  • repl/macroexpand-1
  • repl/macroexpand-1-form
  • repl/macroexpand-form
  • repl/ns-aliases
  • repl/ns-list
  • repl/ns-publics
  • repl/ns-refers
  • repl/print-colorful
  • repl/println-colorful
  • repl/require
  • repl/search-doc
  • repl/source
  • repl/symbol-info
  • repl/test-ns
  • repl/use

• str

  • str/blank?
  • str/capitalize
  • str/chars
  • str/contains?
  • str/ends-with?
  • str/escape
  • str/includes?
  • str/index-of
  • str/join
  • str/last-index-of
  • str/lower-case
  • str/pad-both
  • str/pad-left
  • str/pad-right
  • str/re-quote-replacement
  • str/repeat
  • str/replace
  • str/replace-first
  • str/reverse
  • str/split
  • str/split-lines
  • str/starts-with?
  • str/subs
  • str/trim
  • str/trim-newline
  • str/triml
  • str/trimr
  • str/upper-case

• test

  • test/*testing-contexts*
  • test/are
  • test/assert-expr
  • test/assert-expr-methods
  • test/deftest
  • test/do-report
  • test/get-stats
  • test/is
  • test/print-summary
  • test/report
  • test/reset-stats
  • test/restore-stats
  • test/run-tests
  • test/successful?
  • test/testing

Tip: This documentation is also available in JSON format at /api.json.

base64#

base64/decode#

(decode s & [strict?])

Decodes a Base64 string. Optional strict? flag validates characters.

Example:

(decode "SGVsbG8=") ; => "Hello"

base64/decode-url#

(decode-url s & [strict?])

Decodes a URL-safe Base64 string. Adds padding automatically.

Example:

(decode-url "SGVsbG8") ; => "Hello"

base64/encode#

(encode s)

Encodes a string to Base64.

Example:

(encode "Hello") ; => "SGVsbG8="

base64/encode-url#

(encode-url s)

Encodes a string to URL-safe Base64 (no padding).

Example:

(encode-url "Hello") ; => "SGVsbG8"

core#

%#

(% dividend divisor)

Return the remainder of dividend / divisor.

*#

(* & xs)

Returns the product of all elements in xs. All elements in xs must be numbers. If xs is empty, return 1.

**#

(** a x)

Return a to the power of x.

*assert*#

Controls whether assert expands to a runtime check. When logical false at macroexpansion time, assert expands to nil and performs no runtime check, matching Clojure's compile-time *assert* semantics. Defaults to true. To disable globally, set the core binding before compilation via PHP: \Phel::addDefinition("phel\\core", "*assert*", false).

*build-mode*#

Set to true when a file is being built/compiled, false otherwise.

*file*#

*file*

Returns the path of the current source file.

Example:

(println *file*) ; => "/path/to/current/file.phel"

*hierarchy*#

Global hierarchy for keyword/symbol taxonomies.

*ns*#

*ns*

Returns the namespace in the current scope.

Example:

(println *ns*) ; => "my-app\core"

*program*#

The script path or namespace being executed.

+#

(+ & xs)

Returns the sum of all elements in xs. All elements xs must be numbers. If xs is empty, return 0.

-#

(- & xs)

Returns the difference of all elements in xs. If xs is empty, return 0. If xs has one element, return the negative value of that element.

->#

(-> x & forms)

Threads the expr through the forms. Inserts x as the second item in the first form, making a list of it if it is not a list already. If there are more forms, insert the first form as the second item in the second form, etc.

->>#

(->> x & forms)

Threads the expr through the forms. Inserts x as the last item in the first form, making a list of it if it is not a list already. If there are more forms, insert the first form as the last item in the second form, etc.

/#

(/ & xs)

Returns the nominator divided by all the denominators. If xs is empty, returns 1. If xs has one value, returns the reciprocal of x.

<#

(< a & more)

Checks if each argument is strictly less than the following argument.

Example:

(< 1 2 3 4) ; => true

<=#

(<= a & more)

Checks if each argument is less than or equal to the following argument. Returns a boolean.

<=>#

(<=> a b)

Alias for the spaceship PHP operator in ascending order. Returns an int.

=#

(= a & more)

Checks if all values are equal (value equality, not identity).

Example:

(= [1 2 3] [1 2 3]) ; => true

>#

(> a & more)

Checks if each argument is strictly greater than the following argument.

Example:

(> 4 3 2 1) ; => true

>=#

(>= a & more)

Checks if each argument is greater than or equal to the following argument. Returns a boolean.

>=<#

(>=< a b)

Alias for the spaceship PHP operator in descending order. Returns an int.

NAN#

Constant for Not a Number (NAN) values.

NaN?#

(NaN? x)

Checks if x is not a number. Alias for nan?, matching Clojure's NaN?.

abs#

(abs x)

Returns the absolute value of x. Throws InvalidArgumentException if x is not a number, matching Clojure rather than PHP's permissive abs(null) => 0 / abs("abc") coercions.

Example:

(abs -5) ; => 5

aclone#

(aclone arr)

Returns a shallow copy of a PHP array. The returned array is a distinct value — mutating the copy via php/aset does not affect the original, and vice versa. Matches Clojure's aclone for .cljc interop; raises InvalidArgumentException on non-array inputs since Phel's persistent collections are already immutable and don't need cloning.

Example:

(aclone (object-array 3)) ; => a fresh PHP array [nil, nil, nil]

add-watch#

(add-watch variable key f)

Adds a watch function to a variable. The watch fn is called when the variable changes with four arguments: key, ref, old-value, new-value.

Example:

(add-watch my-var :logger (fn [key ref old new] (println old "->" new)))

all?#

(all? pred coll)

Returns true if predicate is true for every element in collection, false otherwise.

Example:

(all? even? [2 4 6 8]) ; => true

ancestors#

(ancestors tag)

Returns the set of all transitive ancestors of tag, or nil.

and#

(and & args)

Evaluates expressions left to right, returning the first falsy value or the last value.

Example:

(and true 1 "hello") ; => "hello"

apply#

(apply f expr*)

Calls the function with the given arguments. The last argument must be a list of values, which are passed as separate arguments, rather than a single list. Apply returns the result of the calling function.

Example:

(apply + [1 2 3]) ; => 6

argv#

Vector of user arguments passed to the script (excludes program name). Use program to get the script path or namespace.

array-map#

Constructs a map from the given key/value pairs. If any keys are equal, later values replace earlier ones, as if by repeated assoc. Phel has no distinct array-map type, so the result is the same persistent map as hash-map — array-map exists for .cljc interop with Clojure sources.

Example:

(array-map :a 1 :b 2) ; => {:a 1 :b 2}

as->#

(as-> expr name & forms)

Binds name to expr, evaluates the first form in the lexical context of that binding, then binds name to that result, repeating for each successive form, returning the result of the last form.

assert#

(assert expr & [message])

Throws an exception if expr is falsy. Optional message string. Used for precondition checking in application code. When *assert* is logical false at macroexpansion time, assert expands to nil and performs no runtime check.

assoc#

(assoc ds key value & more)

Associates one or more key-value pairs with a collection. Additional key-value pairs beyond the first are applied in order. Throws if an odd number of extra arguments is provided.

Example:

(assoc {:a 1} :b 2) ; => {:a 1 :b 2}
(assoc {:a 1} :b 2 :c 3) ; => {:a 1 :b 2 :c 3}

assoc!#

(assoc! tcoll key value & more)

Associates one or more key-value pairs with a transient collection, mutating it in place. Works on transient hash-maps and transient vectors. Variadic forms apply each key-value pair in order. Raises InvalidArgumentException when tcoll is not a supported transient collection or when an odd number of extra arguments is provided. Matches Clojure's assoc! semantics.

Example:

(persistent! (assoc! (transient {}) :a 1 :b 2)) ; => {:a 1 :b 2}

assoc-in#

(assoc-in ds [k & ks] v)

Associates a value in a nested data structure at the given path.

Creates intermediate maps if they don't exist.

Example:

(assoc-in {:a {:b 1}} [:a :c] 2) ; => {:a {:b 1 :c 2}}

associative?#

(associative? x)

Returns true if x is an associative data structure, false otherwise.

Associative data structures include vectors, hash maps, structs, and PHP arrays (both indexed and associative), matching Clojure's Associative protocol.

Example:

(associative? [1 2 3]) ; => true

atom#

(atom value)

Creates a new atom with the given value.

Atoms provide a way to manage mutable state. Use reset! to set a new value and swap! to update based on the current value.

Example:

(def counter (atom 0))

atom?#

(atom? x)

Returns true if the given value is an atom.

binding#

(binding bindings & body)

Temporary redefines definitions while executing the body. The value will be reset after the body was executed.

bit-and#

(bit-and x y & args)

Bitwise and.

bit-clear#

(bit-clear x n)

Clear bit an index n.

bit-flip#

(bit-flip x n)

Flip bit at index n.

bit-not#

(bit-not x)

Bitwise complement.

bit-or#

(bit-or x y & args)

Bitwise or.

bit-set#

(bit-set x n)

Set bit an index n.

bit-shift-left#

(bit-shift-left x n)

Bitwise shift left.

bit-shift-right#

(bit-shift-right x n)

Bitwise shift right.

bit-test#

(bit-test x n)

Test bit at index n.

bit-xor#

(bit-xor x y & args)

Bitwise xor.

boolean#

(boolean x)

Coerces x to a boolean. Returns false if x is nil or false, true otherwise.

Example:

(boolean nil) ; => false

boolean?#

(boolean? x)

Returns true if x is a boolean, false otherwise.

butlast#

(butlast coll)

Returns all but the last item in coll.

Example:

(butlast [1 2 3 4]) ; => [1 2 3]

byte#

(byte x)

Coerces x to a signed 8-bit integer in the range -128..127. Decimal values are truncated toward zero (as in Clojure on the JVM). Values outside the range or non-numeric inputs raise InvalidArgumentException. Phel has no dedicated byte type, so the result is a plain PHP int — byte exists for .cljc interop with Clojure sources.

Example:

(byte 127) ; => 127
(byte 1.9) ; => 1
(byte -128) ; => -128

case#

(case e & pairs)

Evaluates expression and matches it against constant test values, returning the associated result.

Example:

(case x 1 "one" 2 "two" "other") ; => "one" (when x is 1)

cat#

(cat rf)

A transducer that concatenates the contents of each input into the reduction.

catch#

(catch exception-type exception-name expr*)

Handle exceptions thrown in a try block by matching on the provided exception type. The caught exception is bound to exception-name while evaluating the expressions.

Example:

(try (throw (php/new \Exception "error")) (catch \Exception e (php/-> e (getMessage))))

char#

(char x)

Coerces x to a single-character string representing the given Unicode code point. Accepts a non-negative integer (the code point, converted via mb_chr) or a single-character string, which is returned as-is. Phel has no dedicated char type — character literals such as \A are already single-character strings — so the result is always a plain string. Matches Clojure's char for .cljc interop; raises InvalidArgumentException on negative ints, non-single-character strings, and all other inputs.

Example:

(char 65) ; => "A"
(char 32) ; => " "
(char \A) ; => "A"

char?#

(char? x)

Returns true if x is a single-character string, false otherwise. Phel has no dedicated character type — character literals such as \A are already single-character strings — so char? is true for any string of length 1 (UTF-8 counted). Matches ClojureScript's char? for .cljc interop; Clojure/JVM's char? tests for the distinct Character type, which does not exist here.

Example:

(char? \A) ; => true
(char? "a") ; => true
(char? "ab") ; => false

coerce-in#

(coerce-in v min max)

Returns v if it is in the range, or min if v is less than min, or max if v is greater than max.

coll?#

(coll? x)

Returns true if x is a persistent collection — vector, list, hash-map (including sorted-map), struct, set (including sorted-set), or lazy-seq — and false otherwise. Strings, numbers, nil, booleans, keywords, symbols, and plain PHP arrays are not considered collections, matching Clojure's IPersistentCollection membership.

Example:

(coll? [1 2 3]) ; => true
(coll? "abc") ; => false

comment#

(comment &)

Ignores the body of the comment.

comp#

(comp & fs)

Takes a list of functions and returns a function that is the composition of those functions.

compact#

(compact coll & values)

Returns a lazy sequence with specified values removed from coll. If no values are specified, removes nil values by default.

Example:

(compact [1 nil 2 nil 3]) ; => (1 2 3)

compare#

(compare x y)

Wrapper for PHP's spaceship operator (php/<=>). Returns an integer less than, equal to, or greater than zero when x is less than, equal to, or greater than y, respectively.

compile#

(compile form)

Returns the compiled PHP code string for the given form.

complement#

(complement f)

Returns a function that takes the same arguments as f and returns the opposite truth value.

completing#

(completing f & args)

Takes a reducing function f of 2 args and returns a fn suitable for transduce by adding a 1-arity (completion) that calls cf (default: identity).

concat#

(concat & colls)

Concatenates multiple collections into a lazy sequence.

Example:

(concat [1 2] [3 4]) ; => (1 2 3 4)

cond#

(cond & pairs)

Evaluates test/expression pairs, returning the first matching expression.

Example:

(cond (< x 0) "negative" (> x 0) "positive" "zero") ; => "negative", "positive", or "zero" depending on x

cond->#

(cond-> expr & clauses)

Takes an expression and a set of test/form pairs. Threads expr (via ->) through each form for which the corresponding test expression is true. Note that, unlike cond branching, cond-> threading does not short-circuit after the first true test expression.

Example:

(cond-> 1 true inc false (* 42) true (* 3)) ; => 6

cond->>#

(cond->> expr & clauses)

Takes an expression and a set of test/form pairs. Threads expr (via ->>) through each form for which the corresponding test expression is true. Note that, unlike cond branching, cond->> threading does not short-circuit after the first true test expression.

Example:

(cond->> [1 2 3] true (map inc) false (filter odd?)) ; => [2 3 4]

condp#

(condp pred expr & clauses)

Takes a binary predicate, an expression, and a set of clauses. Each clause takes the form of either: test-expr result-expr test-expr :>> result-fn For each clause, (pred test-expr expr) is evaluated. If it returns logical true, the clause is a match. If a binary clause is a match, result-expr is returned. If a ternary clause with :>> is a match, the result of (pred test-expr expr) is passed to result-fn and the return value is the result. If no clause matches, the default value is returned (if provided), otherwise an exception is thrown.

Example:

(condp = 1 1 "one" 2 "two" "other") ; => "one"

conj#

(conj)
(conj coll)
(conj coll value)
(conj coll value & more)

Returns a new collection with values added. Appends to vectors/sets, prepends to lists.

Example:

(conj [1 2] 3) ; => [1 2 3]

conj!#

(conj!)
(conj! tcoll)
(conj! tcoll value)
(conj! tcoll value & more)

Adds value to the transient collection tcoll, mutating it in place, and returns tcoll. The 'addition' may happen at different 'places' depending on the concrete transient type: transient vectors append at the tail, transient hash-sets add the element (no-op if already present), and transient hash-maps treat value as a [key value] pair (or an associative collection of entries). With zero arguments returns a new empty transient vector. With one argument returns tcoll unchanged. Variadic forms reduce conj! over the remaining values. Raises InvalidArgumentException when tcoll is not a transient collection. Matches Clojure's conj! semantics.

Example:

(persistent (conj! (transient [1 2]) 3)) ; => [1 2 3]

cons#

(cons x coll)

Prepends an element to the beginning of a collection.

Example:

(cons 0 [1 2 3]) ; => [0 1 2 3]

constantly#

(constantly x)

Returns a function that always returns x and ignores any passed arguments.

contains-value?#

(contains-value? coll val)

Returns true if the value is present in the given collection, otherwise returns false.

Example:

(contains-value? {:a 1 :b 2} 2) ; => true

contains?#

(contains? coll key)

Returns true if key is present in collection (checks keys/indices, not values).

Example:

(contains? [10 20 30] 1) ; => true

count#

(count coll)

Counts the number of elements in a sequence. Can be used on everything that implements the PHP Countable interface.

Works with lists, vectors, hash-maps, sets, strings, and PHP arrays. Returns 0 for nil.

Example:

(count [1 2 3]) ; => 3

counted?#

(counted? coll)

Returns true if coll can report its length in constant time — persistent vectors, lists, hash-maps (including sorted-map), structs, and sets (including sorted-set). Returns false for lazy sequences (counting them requires realizing the whole sequence), strings, numbers, nil, and every other non-counted type. Matches Clojure's counted? semantics, which mirror the clojure.lang.Counted marker interface.

Example:

(counted? [1 2 3]) ; => true
(counted? (range)) ; => false

csv-seq#

(csv-seq filename)
(csv-seq filename options)

Returns a lazy sequence of rows from a CSV file.

Example:

(take 10 (csv-seq "data.csv")) ; => [["col1" "col2"] ["val1" "val2"] ...]

cycle#

(cycle coll)

Returns an infinite lazy sequence that cycles through the elements of collection.

Example:

(take 7 (cycle [1 2 3])) ; => (1 2 3 1 2 3 1)

dec#

(dec x)

Decrements x by one.

declare#

Declare a global symbol before it is defined.

dedupe#

(dedupe & args)

Returns a lazy sequence with consecutive duplicate values removed in coll. When called with no args, returns a transducer.

Example:

(dedupe [1 1 2 2 2 3 1 1]) ; => (1 2 3 1)

deep-merge#

(deep-merge & args)

Recursively merges data structures.

def#

(def name meta? value)

This special form binds a value to a global symbol.

Example:

(def my-value 42)

def-#

Define a private value that will not be exported.

defexception#

(defexception name)

Define a new exception.

defexception*#

(defexception my-ex)

Define a new exception.

Example:

(defexception my-error)

definterface#

(definterface name & fns)

An interface in Phel defines an abstract set of functions. It is directly mapped to a PHP interface. An interface can be defined by using the definterface macro.

Example:

(definterface name & fns)

definterface*#

(definterface name & fns)

An interface in Phel defines an abstract set of functions. It is directly mapped to a PHP interface. An interface can be defined by using the definterface macro.

Example:

(definterface Greeter (greet [name]))

defmacro#

Define a macro.

defmacro-#

(defmacro- name & fdecl)

Define a private macro that will not be exported.

defmethod#

(defmethod multi-name dispatch-val & fn-tail)

Registers a method implementation for a multimethod.

multi-name is the name of the multimethod defined by defmulti. When extending a multimethod from a different namespace, fully qualify the multi-name (e.g. phel\test/assert-expr) so the methods table is resolved in the multimethod's home namespace. dispatch-val is the value that triggers this method. args and body define the function implementation.

Example:

(defmethod area :circle [{:radius r}] (* 3.14159 r r))

defmulti#

(defmulti name dispatch-fn)

Defines a multimethod. dispatch-fn is called on the arguments to produce a dispatch value, which is then used to select the appropriate method registered via defmethod.

If no method matches the dispatch value, the :default method is used (if defined), otherwise an error is thrown.

Example:

(defmulti area :shape)

defn#

Define a new global function.

defn-#

(defn- name & fdecl)

Define a private function that will not be exported.

defprotocol#

(defprotocol protocol-name & method-specs)

Defines a protocol with the given method signatures. Each method signature is a list of (method-name [args]).

Creates a dispatching function for each method that dispatches on the type of the first argument. Use extend-type to add implementations.

A :default type can be registered via extend-type as a fallback when no specific type implementation is found.

Example:

(defprotocol Stringable (to-string [this]))

defrecord#

(defrecord name fields & impls)

Defines a record type with the given fields, matching Clojure's defrecord.

Expands to a defstruct plus Clojure-style factory functions:

• Name — positional constructor (from defstruct)
• Name? — type predicate (from defstruct)
• ->Name — positional factory, identical to Name
• map->Name — map factory that takes {:field value ...}

An optional tail of protocol/method forms is spliced into an extend-type call, so inline protocol implementations work exactly like Clojure's defrecord body. Only Phel protocols are supported in the inline tail; PHP interface implementations remain on defstruct.

Example:

(defrecord Point [x y] Drawable (draw [this canvas] ...))

defstruct#

(defstruct name keys & implementations)

A Struct is a special kind of Map. It only supports a predefined number of keys and is associated to a global name. The Struct not only defines itself but also a predicate function.

defstruct*#

(defstruct my-struct [a b c])

A Struct is a special kind of Map. It only supports a predefined number of keys and is associated to a global name. The Struct not only defines itself but also a predicate function.

Example:

(defstruct point [x y])

deftype#

(deftype name fields & impls)

Defines a type with the given fields, matching Clojure's deftype syntax.

Expands to a defstruct plus a Clojure-style positional factory:

• Name — positional constructor (from defstruct)
• Name? — type predicate (from defstruct)
• ->Name — positional factory, identical to Name

Unlike defrecord, no map->Name factory is generated.

An optional tail of protocol/method forms is spliced into an extend-type call. Only Phel protocols are supported in the inline tail.

Deviation from Clojure: Phel's deftype shares the map-backed defstruct infrastructure, so instances remain map-like (keys are accessible via get). Clojure's deftype produces a non-map type; if you need that semantic, use native PHP interop.

Example:

(deftype PointT [x y] Drawable (draw [this canvas] ...))

delay#

(delay & body)

Takes a body of expressions and yields a Delay object that will invoke the body only the first time it is forced (via force or deref/@), caching the result.

Example:

(def d (delay (println "computing") 42))

delay?#

(delay? x)

Returns true if x is a Delay.

deref#

(deref variable & args)

Returns the current value inside the variable.

With three arguments, and when variable is a PhelFuture, blocks for at most timeout-ms milliseconds waiting for the future to resolve. If the future has not completed within the timeout, returns timeout-val. The 3-arg form is only supported on PhelFuture.

Example:

(deref (atom 42)) ; => 42

derive#

(derive child parent)

Establishes a parent/child relationship between child and parent keywords in the global hierarchy. Throws on cyclic derivation.

Example:

(derive :square :shape)

descendants#

(descendants tag)

Returns the set of all descendants of tag, or nil.

difference#

(difference set & sets)

Difference between multiple sets into a new one.

disj#

(disj set)
(disj set k)
(disj set k & ks)

Returns a new set that does not contain the given key(s). Works on hash-sets and sorted-sets. Removing a non-existent key is a no-op. Returns nil when called on nil.

Example:

(disj #{1 2 3} 2) ; => #{1 3}

disj!#

(disj! tcoll)
(disj! tcoll value)
(disj! tcoll value & more)

Removes one or more elements from a transient set, mutating it in place. Raises InvalidArgumentException when tcoll is not a transient set. Matches Clojure's disj! semantics.

Example:

(persistent! (disj! (transient #{1 2 3}) 2)) ; => #{1 3}

dissoc#

(dissoc ds key)

Dissociates key from the datastructure ds. Returns ds without key.

Example:

(dissoc {:a 1 :b 2} :b) ; => {:a 1}

dissoc!#

(dissoc! tcoll)
(dissoc! tcoll key)
(dissoc! tcoll key & ks)

Dissociates one or more keys from a transient map, mutating it in place. Raises InvalidArgumentException when tcoll is not a transient map. Matches Clojure's dissoc! semantics.

Example:

(persistent! (dissoc! (transient {:a 1 :b 2}) :a)) ; => {:b 2}

dissoc-in#

(dissoc-in ds [k & ks])

Dissociates a value from a nested data structure at the given path.

Example:

(dissoc-in {:a {:b 1 :c 2}} [:a :b]) ; => {:a {:c 2}}

distinct#

(distinct & args)

Returns a lazy sequence with duplicated values removed in coll. When called with no args, returns a transducer.

Example:

(distinct [1 2 1 3 2 4 3]) ; => (1 2 3 4)

do#

(do expr*)

Evaluates the expressions in order and returns the value of the last expression. If no expression is given, nil is returned.

Example:

(do (println "Hello") (+ 1 2)) ; prints "Hello", returns 3

doall#

(doall coll)

Forces realization of a lazy sequence and returns it as a vector.

Example:

(doall (map println [1 2 3])) ; => [nil nil nil]

dofor#

(dofor head & body)

Repeatedly executes body for side effects with bindings and modifiers as provided by for. Returns nil.

dorun#

(dorun coll)

Forces realization of a lazy sequence for side effects, returns nil.

Example:

(dorun (map println [1 2 3])) ; => nil

doseq#

(doseq seq-exprs & body)

Alias for dofor.

dotimes#

(dotimes [binding n] & body)

Evaluates body n times with binding bound to integers from 0 to n-1. Returns nil.

Example:

(dotimes [i 5] (println i))

doto#

(doto x & forms)

Evaluates x then calls all of the methods and functions with the value of x supplied at the front of the given arguments. The forms are evaluated in order. Returns x.

double#

(double x)

Coerces x to a double. In PHP there is no distinction between float and double; both map to the same native PHP float type. Alias for float.

Example:

(double 1) ; => 1.0

double?#

(double? x)

Returns true if x is a floating-point number, false otherwise. Alias for float?, matching Clojure's double? naming. Since Phel uses PHP floats (IEEE 754 doubles) there is no separate single-precision float type.

drop#

(drop n & args)

Drops the first n elements of coll. Returns a lazy sequence. When called with n only, returns a transducer.

Example:

(drop 2 [1 2 3 4 5]) ; => (3 4 5)

drop-last#

(drop-last coll)
(drop-last n coll)

Drops the last n elements of coll. n defaults to 1 when omitted, matching Clojure's (drop-last coll) single-arity form. Returns an empty vector when coll is nil, matching Clojure's (drop-last n nil) → () and aligning with drop/take, which also return an empty result on nil.

Example:

(drop-last [1 2 3 4 5]) ; => [1 2 3 4]
(drop-last 2 [1 2 3 4 5]) ; => [1 2 3]
(drop-last 5 nil) ; => []

drop-while#

(drop-while pred & args)

Drops all elements at the front of coll where (pred x) is true. Returns a lazy sequence. When called with pred only, returns a transducer.

Example:

(drop-while #(< % 5) [1 2 3 4 5 6 3 2 1]) ; => (5 6 3 2 1)

empty?#

(empty? x)

Returns true if x would be 0, "" or empty collection, false otherwise.

eval#

(eval form)

Evaluates a form and return the evaluated results.

even?#

(even? x)

Checks if x is even.

every?#

(every? pred coll)

Returns true if predicate is true for every element in collection, false otherwise. Alias for all?.

Example:

(every? even? [2 4 6 8]) ; => true

ex-cause#

(ex-cause ex)

Returns the cause of an exception, or nil.

ex-data#

(ex-data ex)

Returns the data map from an ex-info exception, or nil if not an ExInfoException.

ex-info#

(ex-info msg data)
(ex-info msg data cause)

Creates an exception with a message and a data map. Optionally takes a cause.

Example:

(throw (ex-info "Invalid input" {:field :email}))

ex-message#

(ex-message ex)

Returns the message of an exception.

extend-protocol#

(extend-protocol protocol-name & specs)

Convenience macro that extends a single protocol to multiple types. Alternates type-specs and method implementations.

Equivalent to multiple extend-type calls.

Example:

(extend-protocol Describable
  :string (describe [s] s)
  :int (describe [n] (str n)))

extend-type#

(extend-type type-spec & specs)

Extends a type with protocol method implementations.

type-spec can be:

• nil for the nil type
• a type keyword matching what type returns: :string, :int, :float, :boolean, :keyword, :symbol, :vector, :list, :hash-map, :set, :var, :function, :php/array
• a symbol for struct names (resolved in current namespace)
• a string for explicit PHP class names (cross-namespace structs)

Note: :struct and :php/object cannot be used as type-specs because protocol dispatch resolves these to their specific PHP class names. Use a struct symbol or PHP class name string instead.

Example:

(extend-type :string Stringable (to-string [s] s))

extends?#

(extends? protocol type-key)

Returns true if the given type-key has implementations for all methods of the protocol. type-key should match what protocol-type-key returns.

Example:

(extends? Stringable :string)

extreme#

(extreme order args)

Returns the most extreme value in args based on the binary order function.

false?#

(false? x)

Checks if value is exactly false (not just falsy).

Example:

(false? nil) ; => false

ffirst#

(ffirst coll)

Same as (first (first coll)).

file-seq#

(file-seq path)

Returns a lazy sequence of all files and directories in a directory tree.

Example:

(filter #(php/str_ends_with % ".phel") (file-seq "src/")) ; => ["src/file1.phel" "src/file2.phel" ...]

filter#

(filter pred & args)

Returns a lazy sequence of elements where predicate returns true. When called with pred only, returns a transducer.

Example:

(filter even? [1 2 3 4 5 6]) ; => (2 4 6)

finally#

(finally expr*)

Evaluate expressions after the try body and all matching catches have completed. The finally block runs regardless of whether an exception was thrown.

Example:

(defn risky-operation [] (throw (php/new \Exception "Error!")))
(defn cleanup [] (println "Cleanup!"))
(try (risky-operation) (catch \Exception e nil) (finally (cleanup)))

find#

(find pred coll)

Returns the first item in coll where (pred item) evaluates to true.

Example:

(find #(> % 5) [1 2 3 6 7 8]) ; => 6

find-hierarchy-method#

(find-hierarchy-method methods dispatch-val)

Finds the best matching method for dispatch-val using the global hierarchy. Returns the method function or nil. Used internally by defmulti.

find-index#

(find-index pred coll)

Returns the index of the first item in coll where (pred item) evaluates to true.

Example:

(find-index #(> % 5) [1 2 3 6 7 8]) ; => 3

first#

Returns the first element of a sequence, or nil if empty.

Example:

(first [1 2 3]) ; => 1

flatten#

(flatten coll)

Flattens nested sequential structure into a lazy sequence of all leaf values.

Example:

(flatten [[1 2] [3 [4 5]] 6]) ; => (1 2 3 4 5 6)

float#

(float x)

Coerces x to a float. In PHP there is no distinction between float and double; both map to the same native PHP float type. Delegates to PHP's floatval, so non-numeric strings return 0.0 and nil returns 0.0.

Example:

(float 1) ; => 1.0

float?#

(float? x)

Returns true if x is float point number, false otherwise.

fn#

(fn [params*] expr*)

Defines a function. A function consists of a list of parameters and a list of expression. The value of the last expression is returned as the result of the function. All other expression are only evaluated for side effects. If no expression is given, the function returns nil.

Example:

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

fn?#

(fn? x)

Returns true if x is a function, false otherwise.

fnil#

(fnil f & defaults)

Returns a function that replaces nil arguments with the provided defaults before calling f. The number of defaults determines how many leading arguments are nil-checked.

Example:

(let [safe-inc (fnil inc 0)] (safe-inc nil)) ; => 1

for#

(for head & body)

List comprehension. The head of the loop is a vector that contains a sequence of bindings modifiers and options. A binding is a sequence of three values binding :verb expr. Where binding is a binding as in let and :verb is one of the following keywords:

• :range loop over a range by using the range function.
• :in loops over all values of a collection (including strings).
• :keys loops over all keys/indexes of a collection.
• :pairs loops over all key-value pairs of a collection.

After each loop binding, additional modifiers can be applied. Modifiers have the form :modifier argument. The following modifiers are supported:

• :while breaks the loop if the expression is falsy.
• :let defines additional bindings.
• :when only evaluates the loop body if the condition is true.

Finally, additional options can be set:

• :reduce [accumulator initial-value] Instead of returning a list, it reduces the values into accumulator. Initially accumulator is bound to initial-value.

Example:

(for [x :in [1 2 3]] (* x 2)) ; => [2 4 6]

force#

(force x)

If x is a Delay, forces it and returns its cached value. Otherwise returns x.

Example:

(force (delay 42)) ; => 42

foreach#

(foreach [value valueExpr] expr*)
(foreach [key value valueExpr] expr*)

The foreach special form can be used to iterate over all kind of PHP datastructures. The return value of foreach is always nil. The loop special form should be preferred of the foreach special form whenever possible.

Example:

(foreach [x [1 2 3]] (println x))

format#

(format fmt & xs)

Returns a formatted string. See PHP's sprintf for more information.

frequencies#

(frequencies coll)

Returns a map from distinct items in coll to the number of times they appear.

Works with vectors, lists, sets, and strings.

Example:

(frequencies [:a :b :a :c :b :a]) ; => {:a 3 :b 2 :c 1}

full-name#

(full-name x)

Return the namespace and name string of a string, keyword or symbol.

function?#

Deprecated: 0.32.0 — Use fn? instead

(function? x)

Returns true if x is a function, false otherwise.

gensym#

(gensym)

Generates a new unique symbol.

get#

(get ds k & [opt])

Gets the value at key in a collection. Returns default if not found.

Example:

(get {:a 1} :a) ; => 1

get-in#

(get-in ds ks & [opt])

Accesses a value in a nested data structure via a sequence of keys.

Returns opt (default nil) if the path doesn't exist.

Example:

(get-in {:a {:b {:c 42}}} [:a :b :c]) ; => 42

get-validator#

(get-validator variable)

Returns the validator function of a variable, or nil.

group-by#

(group-by f coll)

Returns a map of the elements of coll keyed by the result of f on each element.

Example:

(group-by count ["a" "bb" "c" "ddd" "ee"]) ; => {1 ["a" "c"] 2 ["bb" "ee"] 3 ["ddd"]}

hash-map#

(hash-map :a 1 :b 2) ; => {:a 1 :b 2}

Creates a new hash map. If no argument is provided, an empty hash map is created. The number of parameters must be even. Shortcut: {}

Example:

(hash-map :name "Alice" :age 30) ; => {:name "Alice" :age 30}

hash-map?#

Deprecated: 0.32.0 — Use map? instead

(hash-map? x)

Returns true if x is a hash map, false otherwise.

hash-set#

(hash-set & xs)

Creates a new Set from the given arguments. Shortcut: #{}

Example:

(hash-set 1 2 3) ; => #{1 2 3}

id#

Deprecated: 0.32.0 — Use identical? instead

(id a & more)

Checks if all values are identical. Same as a === b in PHP.

identical?#

(identical? a & more)

Checks if all values are identical. Same as a === b in PHP.

identity#

(identity x)

Returns its argument.

if#

(if test then else?)

A control flow structure. First evaluates test. If test evaluates to true, only the then form is evaluated and the result is returned. If test evaluates to false only the else form is evaluated and the result is returned. If no else form is given, nil will be returned.

The test evaluates to false if its value is false or equal to nil. Every other value evaluates to true. In sense of PHP this means (test != null && test !== false).

Example:

(if (> x 0) "positive" "non-positive")

if-let#

(if-let bindings then & [else])

If test is true, evaluates then with binding-form bound to the value of test, if not, yields else

if-not#

(if-not test then & [else])

Evaluates then if test is false, else otherwise.

Example:

(if-not (< 5 3) "not less" "less") ; => "not less"

if-some#

(if-some bindings then & [else])

Binds name to the value of test. If test is not nil, evaluates then with binding-form bound to the value of test, if not, yields else. Unlike if-let, false and 0 are not treated as falsy — only nil triggers the else branch.

inc#

(inc x)

Increments x by one.

indexed?#

(indexed? x)

Returns true if x is an indexed sequence, false otherwise.

Indexed sequences include lists, vectors, and indexed PHP arrays.

Example:

(indexed? [1 2 3]) ; => true

inf?#

(inf? x)

Checks if x is infinite.

Example:

(inf? php/INF) ; => true

int?#

(int? x)

Returns true if x is an integer number, false otherwise. Alias for integer?.

Note that, unlike Clojure, Phel uses PHP integers and there is no distinction between standard and fixed-precision integers. Integer sizes are also limited by platform (see php/PHP_INT_MAX constant).

integer?#

(integer? x)

Returns true if x is an integer number, false otherwise.

interleave#

(interleave & colls)

Interleaves multiple collections. Returns a lazy sequence.

Returns elements by taking one from each collection in turn. Pads with nil when collections have different lengths. Works with infinite sequences.

Example:

(interleave [1 2 3] [:a :b :c]) ; => (1 :a 2 :b 3 :c)

interpose#

(interpose sep & args)

Returns elements separated by a separator. Returns a lazy sequence. When called with sep only, returns a transducer.

Example:

(interpose 0 [1 2 3]) ; => (1 0 2 0 3)

intersection#

(intersection set & sets)

Intersect multiple sets into a new one.

into#

(into to & rest)

Returns to with all elements of from added.

When from is associative, it is treated as a sequence of key-value pairs. Supports persistent and transient collections.

Example:

(into [] '(1 2 3)) ; => [1 2 3]

invert#

(invert map)

Returns a new map where the keys and values are swapped.

If map has duplicated values, some keys will be ignored.

Example:

(invert {:a 1 :b 2 :c 3}) ; => {1 :a 2 :b 3 :c}

isa?#

(isa? child parent)

Returns true if child equals parent, or child is a descendant of parent in the global hierarchy.

Example:

(do (derive :square :shape) (isa? :square :shape)) ; => true

iterate#

(iterate f x)

Returns an infinite lazy sequence of x, (f x), (f (f x)), and so on.

Example:

(take 5 (iterate inc 0)) ; => (0 1 2 3 4)

iteration#

(iteration step opts)

Creates a lazy sequence from successive calls to step. step is called with a key (starting with :initk) and returns a result. :kf extracts the next key, :vf extracts the value from the result. Terminates when the result is nil.

Options map keys: :kf — key function (default: identity) :vf — value function (default: identity) :initk — initial key (default: nil)

Example:

(iteration fetch-page {:kf :next-token :vf :items :initk nil})

juxt#

(juxt & fs)

Takes a list of functions and returns a new function that is the juxtaposition of those functions.

Example:

((juxt inc dec #(* % 2)) 10) => [11 9 20]

keep#

(keep pred & args)

Returns a lazy sequence of non-nil results of applying function to elements. When called with f only, returns a transducer.

Example:

(keep #(when (even? %) (* % %)) [1 2 3 4 5]) ; => (4 16)

keep-indexed#

(keep-indexed pred & args)

Returns a lazy sequence of non-nil results of (pred i x). When called with f only, returns a transducer.

Example:

(keep-indexed #(when (even? %1) %2) ["a" "b" "c" "d"]) ; => ("a" "c")

keys#

(keys coll)

Returns a sequence of all keys in a map.

Example:

(keys {:a 1 :b 2}) ; => (:a :b)

keyword#

(keyword x)

Creates a new Keyword from a given string.

Example:

(keyword "name") ; => :name

keyword?#

(keyword? x)

Returns true if x is a keyword, false otherwise.

kvs#

(kvs coll)

Returns a vector of key-value pairs like [k1 v1 k2 v2 k3 v3 ...].

Example:

(kvs {:a 1 :b 2}) ; => [:a 1 :b 2]

last#

(last coll)

Returns the last element of coll or nil if coll is empty or nil.

Example:

(last [1 2 3]) ; => 3

lazy-cat#

(lazy-cat & colls)

Concatenates collections into a lazy sequence (expands to concat).

Example:

(lazy-cat [1 2] [3 4]) ; => (1 2 3 4)

lazy-seq#

(lazy-seq & body)

Creates a lazy sequence that evaluates the body only when accessed.

Example:

(lazy-seq (cons 1 (lazy-seq nil))) ; => (1)

let#

(let [bindings*] expr*)

Creates a new lexical context with assignments defined in bindings. Afterwards the list of expressions is evaluated and the value of the last expression is returned. If no expression is given nil is returned.

Example:

(let [x 1 y 2] (+ x y)) ; => 3

letfn#

(letfn bindings & body)

Defines mutually recursive local functions.

bindings is a vector of function specs: (letfn [(f [params] body) (g [params] body)] expr) All function names are in scope within all function bodies and the body expression, enabling mutual recursion.

Example:

(letfn [(my-even? [n] (if (zero? n) true (my-odd? (dec n))))
        (my-odd? [n] (if (zero? n) false (my-even? (dec n))))]
  (my-even? 10))

line-seq#

(line-seq filename)

Returns a lazy sequence of lines from a file.

Example:

(take 10 (line-seq "large-file.txt")) ; => ["line1" "line2" ...]

list#

(list 1 2 3) ; => '(1 2 3)

Creates a new list. If no argument is provided, an empty list is created. Shortcut: '()

Example:

(list 1 2 3) ; => '(1 2 3)

list?#

(list? x)

Returns true if x is a list, false otherwise.

loop#

(loop [bindings*] expr*)

Creates a new lexical context with variables defined in bindings and defines a recursion point at the top of the loop.

Example:

(loop [i 0] (if (< i 5) (do (println i) (recur (inc i)))))

macroexpand#

(macroexpand form)

Recursively expands the given form until it is no longer a macro call.

macroexpand-1#

(macroexpand-1 form)

Expands the given form once if it is a macro call.

make-hierarchy#

(make-hierarchy)

Returns a new hierarchy map with no parent relationships.

map#

(map f & colls)

Returns a lazy sequence of the result of applying f to all of the first items in each coll, followed by applying f to all the second items in each coll until anyone of the colls is exhausted.

When given a single collection, applies the function to each element. With multiple collections, applies the function to corresponding elements from each collection, stopping when the shortest collection is exhausted.

Example:

(map inc [1 2 3]) ; => (2 3 4)

map-indexed#

(map-indexed f coll)

Maps a function over a collection with index. Returns a lazy sequence.

Applies f to each element in xs. f is a two-argument function where the first argument is the index (0-based) and the second is the element itself. Works with infinite sequences.

Example:

(map-indexed vector [:a :b :c]) ; => ([0 :a] [1 :b] [2 :c])

map?#

(map? x)

Returns true if x is a hash map, false otherwise.

mapcat#

(mapcat f & args)

Maps a function over a collection and concatenates the results. Returns a lazy sequence. When called with f only, returns a transducer.

Example:

(mapcat reverse [[1 2] [3 4]]) ; => (2 1 4 3)

max#

(max & numbers)

Returns the numeric maximum of all numbers.

max-key#

(max-key k x & more)

Returns the arg for which (k arg) is largest. On ties, returns the latest argument, matching Clojure semantics.

Example:

(max-key count "bb" "aaa" "b") ; => "aaa"

mean#

(mean xs)

Returns the mean of xs.

median#

(median xs)

Returns the median of xs.

memoize#

(memoize f)

Returns a memoized version of the function f. The memoized function caches the return value for each set of arguments.

Example:

(defn fact [n]
  (if (zero? n)
    1
    (* n (fact (dec n)))))
(def fact-memo (memoize fact))

memoize-lru#

(memoize-lru f)
(memoize-lru f max-size)

Returns a memoized version of the function f with an LRU (Least Recently Used) cache limited to max-size entries. When the cache exceeds max-size, the least recently used entry is evicted. This prevents unbounded memory growth in long-running processes.

Without arguments, uses a default cache size of 128 entries.

Example:

(defn fact [n]
  (if (zero? n)
    1
    (* n (fact (dec n)))))
(def fact-memo (memoize-lru fact 100))

merge#

(merge & maps)

Merges multiple maps into one new map.

If a key appears in more than one collection, later values replace previous ones.

Example:

(merge {:a 1 :b 2} {:b 3 :c 4}) ; => {:a 1 :b 3 :c 4}

merge-with#

(merge-with f & hash-maps)

Merges multiple maps into one new map. If a key appears in more than one collection, the result of (f current-val next-val) is used.

meta#

Gets the metadata attached to a value. For a quoted symbol ((meta 'foo)) the definition metadata registered via def is returned. For any other expression the value is looked up at runtime and its MetaInterface metadata returned.

min#

(min & numbers)

Returns the numeric minimum of all numbers.

min-key#

(min-key k x & more)

Returns the arg for which (k arg) is smallest. On ties, returns the latest argument, matching Clojure semantics.

Example:

(min-key count "bb" "aaa" "b") ; => "b"

name#

(name x)

Returns the name string of a string, keyword or symbol.

namespace#

(namespace x)

Return the namespace string of a symbol or keyword. Nil if not present.

nan?#

(nan? x)

Checks if x is not a number.

neg?#

(neg? x)

Checks if x is smaller than zero.

next#

Returns the sequence after the first element, or nil if empty.

Example:

(next [1 2 3]) ; => [2 3]

nfirst#

(nfirst coll)

Same as (next (first coll)).

nil?#

(nil? x)

Returns true if value is nil, false otherwise.

Example:

(nil? (get {:a 1} :b)) ; => true

nnext#

(nnext coll)

Same as (next (next coll)).

not#

(not x)

Returns true if value is falsy (nil or false), false otherwise.

Example:

(not nil) ; => true

not-any?#

(not-any? pred coll)

Returns true if (pred x) is logical false for every x in coll or if coll is empty. Otherwise returns false.

not-empty#

(not-empty coll)

Returns coll if it contains elements, otherwise nil.

not-every?#

(not-every? pred coll)

Returns false if (pred x) is logical true for every x in collection coll or if coll is empty. Otherwise returns true.

not=#

(not= a & more)

Checks if all values are unequal. Same as a != b in PHP.

ns#

(ns name imports*)

Defines the namespace for the current file and adds imports to the environment. Imports can either be uses or requires. The keyword :use is used to import PHP classes, the keyword :require is used to import Phel modules and the keyword :require-file is used to load php files.

Example:

(ns my-app\core (:require phel\str :as str))

number?#

(number? x)

Returns true if x is a number, false otherwise.

object-array#

(object-array size-or-seq)

Creates a PHP array of the given size initialized to nil, or a PHP array containing the elements of the given sequence. Matches Clojure's object-array for .cljc interop — in Phel the result is a plain PHP array (accessible via php/aget/php/aset) since PHP has no typed array distinction.

Example:

(object-array 3) ; => a PHP array [nil, nil, nil]
(object-array [1 2 3]) ; => a PHP array [1, 2, 3]

odd?#

(odd? x)

Checks if x is odd.

one?#

(one? x)

Checks if x is one.

or#

(or & args)

Evaluates expressions left to right, returning the first truthy value or the last value.

Example:

(or false nil 42 100) ; => 42

pairs#

(pairs coll)

Gets the pairs of an associative data structure.

Example:

(pairs {:a 1 :b 2}) ; => ([:a 1] [:b 2])

parents#

(parents tag)

Returns the set of immediate parents of tag in the global hierarchy, or nil.

parse-boolean#

(parse-boolean s)

Parses a string as a boolean. Returns true for "true", false for "false", nil otherwise.

Example:

(parse-boolean "true") ; => true

parse-double#

(parse-double s)

Parses a string as a float. Returns nil if parsing fails.

Example:

(parse-double "3.14") ; => 3.14

parse-long#

(parse-long s)

Parses a string as an integer. Returns nil if parsing fails.

Example:

(parse-long "123") ; => 123

partial#

(partial f & args)

Takes a function f and fewer than normal arguments of f and returns a function that a variable number of additional arguments. When call f will be called with args and the additional arguments.

partition#

(partition n coll)

Partitions collection into chunks of size n, dropping incomplete final partition.

Example:

(partition 3 [1 2 3 4 5 6 7]) ; => ([1 2 3] [4 5 6])

partition-all#

(partition-all n coll)

Partitions collection into chunks of size n, including incomplete final partition.

Example:

(partition-all 3 [1 2 3 4 5 6 7]) ; => ([1 2 3] [4 5 6] [7])

partition-by#

(partition-by f coll)

Returns a lazy sequence of partitions. Applies f to each value in coll, splitting them each time the return value changes.

Example:

(partition-by #(< % 3) [1 2 3 4 5 1 2]) ; => [[1 2] [3 4 5] [1 2]]

peek#

(peek coll)

Returns the last element of a sequence, or nil if empty or nil. Works on vectors, PHP arrays, lists, and lazy sequences.

Example:

(peek [1 2 3]) ; => 3

persistent#

(persistent coll)

Converts a transient collection back to a persistent collection.

Example:

(def t (transient {}))

persistent!#

(persistent! coll)

Converts a transient collection back to a persistent collection. Alias for persistent, matching Clojure's persistent! naming.

Example:

(persistent! (conj! (transient []) 1 2 3)) ; => [1 2 3]

phel->php#

(phel->php x)

Recursively converts a Phel data structure to a PHP array.

Example:

(phel->php {:a [1 2 3] :b {:c 4}}) ; => (PHP array ["a" => [1, 2, 3], "b" => ["c" => 4]])

php->phel#

(php->phel x)

Recursively converts a PHP array to Phel data structures.

Indexed PHP arrays become vectors, associative PHP arrays become maps.

Example:

(php->phel (php-associative-array "a" 1 "b" 2)) ; => {"a" 1 "b" 2}

php-array-to-map#

(php-array-to-map arr)

Converts a PHP Array to a Phel map.

Example:

(php-array-to-map (php-associative-array "a" 1 "b" 2)) ; => {"a" 1 "b" 2}

php-array?#

(php-array? x)

Returns true if x is a PHP Array, false otherwise.

php-associative-array#

(php-associative-array & xs)

Creates a PHP associative array from key-value pairs.

Arguments: Key-value pairs (must be even number of arguments)

Example:

(php-associative-array "name" "Alice" "age" 30) ; => (PHP array ["name" => "Alice", "age" => 30])

php-indexed-array#

(php-indexed-array & xs)

Creates a PHP indexed array from the given values.

Example:

(php-indexed-array 1 2 3) ; => (PHP array [1, 2, 3])

php-object?#

(php-object? x)

Returns true if x is a PHP object, false otherwise.

php-resource?#

(php-resource? x)

Returns true if x is a PHP resource, false otherwise.

pop#

(pop coll)

Removes the last element of the array coll. If the array is empty returns nil.

pop!#

(pop! tcoll)

Removes the last element from a transient vector, mutating it in place. Raises InvalidArgumentException when tcoll is not a transient vector. Matches Clojure's pop! semantics.

Example:

(persistent! (pop! (transient [1 2 3]))) ; => [1 2]

pos?#

(pos? x)

Checks if x is greater than zero.

print#

(print & xs)

Prints the given values to the default output stream. Returns nil.

print-str#

(print-str & xs)

Same as print. But instead of writing it to an output stream, the resulting string is returned.

printf#

(printf fmt & xs)

Output a formatted string. See PHP's printf for more information.

println#

(println & xs)

Same as print followed by a newline.

protocol-type-key#

(protocol-type-key x)

Returns the dispatch key for protocol dispatch. Returns a type keyword for primitive types, or the PHP class name string for objects/structs.

Optimized to avoid the full type cond chain: checks scalars first (most common in tight loops), then objects.

push#

Deprecated: 0.25.0 — Use conj instead

(push coll x)

Inserts x at the end of the sequence coll.

put#

Deprecated: 0.25.0 — Use assoc instead

(put ds key value)

Puts value mapped to key on the datastructure ds. Returns ds.

put-in#

Deprecated: 0.25.0 — Use assoc-in instead