lang

package

Go to main page

Versions in this module

v0

v0.6.2

Sep 23, 2025

v0.6.1

Sep 20, 2025

Changes in this version

+ var VarLoadFile = InternVar(NSCore, NewSymbol("load-file"), nil, true)

+ func ForceDelay(x any) any

+ type ARef interface

+ type AReference interface

+ AlterMeta func(f IFn, args ISeq) IPersistentMap

+ Meta func() IPersistentMap

+ ResetMeta func(meta IPersistentMap) IPersistentMap

type Agent

+ func (a *Agent) Deref() any

+ func (a *Agent) RemoveWatch(key interface{})

+ func (a *Agent) Watches() IPersistentMap

+ type Counter interface

+ Count func() int

+ type Delay struct

+ func NewDelay(fn IFn) *Delay

+ func (d *Delay) Deref() any

+ func (d *Delay) IsRealized() bool

+ type ExceptionInfo struct

+ func NewExceptionInfo(msg string, data IPersistentMap) *ExceptionInfo

+ func NewExceptionInfoWithCause(msg string, data IPersistentMap, cause error) *ExceptionInfo

+ func (e *ExceptionInfo) Cause() error

+ func (e *ExceptionInfo) Error() string

+ func (e *ExceptionInfo) GetData() IPersistentMap

+ func (e *ExceptionInfo) Is(target error) bool

+ func (e *ExceptionInfo) Message() string

+ func (e *ExceptionInfo) Unwrap() error

+ type IExceptionInfo interface

+ GetData func() IPersistentMap

type IPersistentMap

+ func GetExData(err error) IPersistentMap

+ func GetThreadBindings() IPersistentMap

type ISeq

+ func AllNamespaces() ISeq

+ type ITransientMap interface

+ type Iterate struct

+ func CreateIterate(f IFn, seed any) *Iterate

+ func (it *Iterate) Cons(o any) Conser

+ func (it *Iterate) Count() int

+ func (it *Iterate) Empty() IPersistentCollection

+ func (it *Iterate) Equals(o any) bool

+ func (it *Iterate) Equiv(o any) bool

+ func (it *Iterate) First() any

+ func (it *Iterate) Hash() uint32

+ func (it *Iterate) HashEq() uint32

+ func (it *Iterate) IsRealized() bool

+ func (it *Iterate) Meta() IPersistentMap

+ func (it *Iterate) More() ISeq

+ func (it *Iterate) Next() ISeq

+ func (it *Iterate) Reduce(rf IFn) any

+ func (it *Iterate) ReduceInit(rf IFn, start any) any

+ func (it *Iterate) Seq() ISeq

+ func (it *Iterate) String() string

+ func (it *Iterate) WithMeta(meta IPersistentMap) any

type Keyword

+ func (k Keyword) Sym() *Symbol

type Map

+ func (m *Map) Hash() uint32

type NumberMethods

+ func (nm *NumberMethods) AndNot(x, y any) any

+ func (nm *NumberMethods) DecP(v any) any

+ func (nm *NumberMethods) IncP(v any) any

+ func (nm *NumberMethods) Not(x any) any

+ func (nm *NumberMethods) Or(x, y any) any

+ func (nm *NumberMethods) Rationalize(x any) any

+ func (nm *NumberMethods) Xor(x, y any) any

type PersistentHashMap

+ func (m *PersistentHashMap) Hash() uint32

type PersistentStructMap

+ func (m *PersistentStructMap) Hash() uint32

type Set

+ func NewSet2(vals ...any) (*Set, error)

+ func (s *Set) Hash() uint32

type Symbol

+ func (s *Symbol) ApplyTo(args ISeq) any

+ func (s *Symbol) Invoke(args ...any) any

type Vector

+ func (v *Vector) Hash() uint32

v0.4.0

Sep 2, 2025

Changes in this version

+ func CatchMatches(r, expect any) bool

+ func GetPersistentStructMapAccessor() any

+ func NewCompilerError(file string, line, col int, err error) error

+ func NewUnsupportedOperationError(msg string) error

+ type ArrayList struct

+ func NewArrayList(items []any) *ArrayList

+ func (al *ArrayList) Add(item any)

+ func (al *ArrayList) Clear()

+ func (al *ArrayList) IsEmpty() bool

+ func (al *ArrayList) ToArray() []any

type Atom

+ func NewAtomWithMeta(val any, meta IPersistentMap) *Atom

+ func (a *Atom) Meta() IPersistentMap

type BigDecimal

+ func NewBigDecimalFromRatio(x *Ratio) *BigDecimal

+ func (n *BigDecimal) ToBigFloat() *big.Float

+ type CompilerError struct

+ func (e *CompilerError) Error() string

type Environment

+ LookupLocal func(name string) (any, bool)

+ type EvalError struct

+ func NewEvalError(frame StackFrame, err error) *EvalError

+ func (e *EvalError) AddStack(frame StackFrame) error

+ func (e *EvalError) Error() string

+ func (e *EvalError) Stack() []StackFrame

+ func (e *EvalError) Unwrap() error

+ type FnFunc func(args ...any) any

+ func NewFnFunc(fn func(args ...any) any) FnFunc

+ func (f FnFunc) ApplyTo(args ISeq) any

+ func (f FnFunc) Invoke(args ...any) any

+ func (f FnFunc) Meta() IPersistentMap

+ func (f FnFunc) WithMeta(meta IPersistentMap) any

+ type Iterator interface

+ HasNext func() bool

+ Next func() any

type MultiFn

+ func (m *MultiFn) GetDefaultDispatchVal() any

+ func (m *MultiFn) GetDispatchFn() IFn

+ func (m *MultiFn) GetHierarchy() IRef

+ func (m *MultiFn) GetMethodTable() IPersistentMap

+ func (m *MultiFn) GetName() string

type PersistentStructMap

+ func CreatePersistentStructMap(def *PersistentStructMapDef, keyvals ISeq) *PersistentStructMap

+ type UnsupportedOperationError struct

+ func (e *UnsupportedOperationError) Error() string

+ func (e *UnsupportedOperationError) Is(other error) bool

v0.3.0

Aug 3, 2025

v0.2.7

Aug 2, 2025

Changes in this version

+ func Compare(x, y any) int

+ func SortSlice(slice []any, comp any)

type Keyword

+ func (k Keyword) Compare(other any) int

type MapEntry

+ func (me *MapEntry) Compare(other any) int

type NumberMethods

+ func (nm *NumberMethods) Compare(x, y any) int

type SubVector

+ func (v *SubVector) Compare(other any) int

type Symbol

+ func (s *Symbol) Compare(other any) int

type Vector

+ func (v *Vector) Compare(other any) int

v0.2.6

Oct 13, 2024

v0.2.5

Jul 4, 2024

v0.2.4

May 14, 2024

v0.2.3

May 14, 2024

Changes in this version

type TransientMap

+ func (m *TransientMap) ApplyTo(args ISeq) any

+ func (m *TransientMap) Invoke(args ...any) any

+ func (m *TransientMap) Meta() IPersistentMap

+ func (m *TransientMap) Reduce(f IFn) any

+ func (m *TransientMap) ReduceInit(f IFn, init any) any

v0.2.2

Jan 28, 2024

v0.2.1

Jan 28, 2024

v0.2.0

Nov 24, 2023

v0.1.0

Nov 7, 2023

Changes in this version

+ const CategoryDecimal

+ const CategoryFloating

+ const CategoryInteger

+ const CategoryRatio

+ var BuiltinTypes = map[string]reflect.Type

+ var Builtins = map[string]interface

+ var ErrNoTransaction = errors.New("no transaction running")

+ var KWAliases = NewKeyword("aliases")

+ var KWArg = NewKeyword("arg")

+ var KWArgId = NewKeyword("arg-id")

+ var KWArglists = NewKeyword("arglists")

+ var KWArgs = NewKeyword("args")

+ var KWBinding = NewKeyword("binding")

+ var KWBindings = NewKeyword("bindings")

+ var KWBody = NewKeyword("body")

+ var KWBool = NewKeyword("bool")

+ var KWCase = NewKeyword("case")

+ var KWCaseNode = NewKeyword("case-node")

+ var KWCatch = NewKeyword("catch")

+ var KWCatches = NewKeyword("catches")

+ var KWChar = NewKeyword("char")

+ var KWChildren = NewKeyword("children")

+ var KWClass = NewKeyword("class")

+ var KWColumn = NewKeyword("column")

+ var KWCompact = NewKeyword("compact")

+ var KWConst = NewKeyword("const")

+ var KWContext = NewKeyword("context")

+ var KWCtxExpr = NewKeyword("ctx/expr")

+ var KWCtxReturn = NewKeyword("ctx/return")

+ var KWCtxStatement = NewKeyword("ctx/statement")

+ var KWDef = NewKeyword("def")

+ var KWDefault = NewKeyword("default")

+ var KWDo = NewKeyword("do")

+ var KWDoc = NewKeyword("doc")

+ var KWDynamic = NewKeyword("dynamic")

+ var KWElse = NewKeyword("else")

+ var KWEndColumn = NewKeyword("end-column")

+ var KWEndLine = NewKeyword("end-line")

+ var KWEnv = NewKeyword("env")

+ var KWException = NewKeyword("exception")

+ var KWExpr = NewKeyword("expr")

+ var KWExprs = NewKeyword("exprs")

+ var KWField = NewKeyword("field")

+ var KWFile = NewKeyword("file")

+ var KWFinally = NewKeyword("finally")

+ var KWFixedArity = NewKeyword("fixed-arity")

+ var KWFn = NewKeyword("fn")

+ var KWFnMethod = NewKeyword("fn-method")

+ var KWForm = NewKeyword("form")

+ var KWHashEquiv = NewKeyword("hash-equiv")

+ var KWHashIdentity = NewKeyword("hash-identity")

+ var KWHostCall = NewKeyword("host-call")

+ var KWHostField = NewKeyword("host-field")

+ var KWHostInterop = NewKeyword("host-interop")

+ var KWIf = NewKeyword("if")

+ var KWInTry = NewKeyword("in-try")

+ var KWInit = NewKeyword("init")

+ var KWInt = NewKeyword("int")

+ var KWInvoke = NewKeyword("invoke")

+ var KWIsAssignable = NewKeyword("assignable?")

+ var KWIsBody = NewKeyword("body?")

+ var KWIsLiteral = NewKeyword("literal?")

+ var KWIsVariadic = NewKeyword("variadic?")

+ var KWItems = NewKeyword("items")

+ var KWKeys = NewKeyword("keys")

+ var KWKeyword = NewKeyword("keyword")

+ var KWLet = NewKeyword("let")

+ var KWLetfn = NewKeyword("letfn")

+ var KWLine = NewKeyword("line")

+ var KWLocal = NewKeyword("local")

+ var KWLocals = NewKeyword("locals")

+ var KWLoop = NewKeyword("loop")

+ var KWLoopId = NewKeyword("loop-id")

+ var KWLoopLocals = NewKeyword("loop-locals")

+ var KWMOrF = NewKeyword("m-or-f")

+ var KWMacro = NewKeyword("macro")

+ var KWMap = NewKeyword("map")

+ var KWMappings = NewKeyword("mappings")

+ var KWMaxFixedArity = NewKeyword("max-fixed-arity")

+ var KWMaybeClass = NewKeyword("maybe-class")

+ var KWMaybeHostForm = NewKeyword("maybe-host-form")

+ var KWMeta = NewKeyword("meta")

+ var KWMethod = NewKeyword("method")

+ var KWMethods = NewKeyword("methods")

+ var KWMutable = NewKeyword("mutable")

+ var KWNS = NewKeyword("ns")

+ var KWName = NewKeyword("name")

+ var KWNamespaces = NewKeyword("namespaces")

+ var KWNew = NewKeyword("new")

+ var KWNil = NewKeyword("nil")

+ var KWNodes = NewKeyword("nodes")

+ var KWNumber = NewKeyword("number")

+ var KWOnce = NewKeyword("once")

+ var KWOp = NewKeyword("op")

+ var KWParams = NewKeyword("params")

+ var KWPrivate = NewKeyword("private")

+ var KWQuote = NewKeyword("quote")

+ var KWRawForms = NewKeyword("raw-forms")

+ var KWRecur = NewKeyword("recur")

+ var KWRegex = NewKeyword("regex")

+ var KWRet = NewKeyword("ret")

+ var KWSeq = NewKeyword("seq")

+ var KWSet = NewKeyword("set")

+ var KWSetBang = NewKeyword("set!")

+ var KWSparse = NewKeyword("sparse")

+ var KWStatements = NewKeyword("statements")

+ var KWString = NewKeyword("string")

+ var KWSymbol = NewKeyword("symbol")

+ var KWTag = NewKeyword("tag")

+ var KWTarget = NewKeyword("target")

+ var KWTest = NewKeyword("test")

+ var KWTests = NewKeyword("tests")

+ var KWTheVar = NewKeyword("the-var")

+ var KWThen = NewKeyword("then")

+ var KWThrow = NewKeyword("throw")

+ var KWTopLevel = NewKeyword("top-level")

+ var KWTry = NewKeyword("try")

+ var KWType = NewKeyword("type")

+ var KWUnknown = NewKeyword("unknown")

+ var KWVal = NewKeyword("val")

+ var KWVals = NewKeyword("vals")

+ var KWVar = NewKeyword("var")

+ var KWVector = NewKeyword("vector")

+ var KWWithMeta = NewKeyword("with-meta")

+ var LockingTransaction = &LockingTransactor

+ var Matcher = reflect.TypeOf(&regexp.Regexp{})

+ var NSCore = FindOrCreateNamespace(SymbolCoreNamespace)

+ var Numbers = &NumberMethods

+ var PrintWriter = reflect.TypeOf(&bytes.Buffer{})

+ var SymbolCoreNamespace = NewSymbol("glojure.core")

+ var Throwable = reflect.TypeOf((interface{})(nil))

+ var VarAgent = InternVarReplaceRoot(NSCore, NewSymbol("*agent*"), nil).SetDynamic()

+ var VarAssert = InternVarReplaceRoot(NSCore, NewSymbol("*assert*"), false).SetDynamic()

+ var VarCompileFiles = InternVarReplaceRoot(NSCore, NewSymbol("*compile-files*"), false).SetDynamic()

+ var VarCurrentNS = InternVarReplaceRoot(NSCore, NewSymbol("*ns*"), NSCore).SetDynamic()

+ var VarDataReaders = InternVarReplaceRoot(NSCore, NewSymbol("*data-readers*"), emptyMap).SetDynamic()

+ var VarFile = InternVarReplaceRoot(NSCore, NewSymbol("*file*"), "NO_SOURCE_FILE").SetDynamic()

+ var VarIn = InternVarReplaceRoot(NSCore, NewSymbol("*in*"), os.Stdin).SetDynamic()

+ var VarInNS = InternVar(NSCore, NewSymbol("in-ns"), false, true)

+ var VarNS = InternVar(NSCore, NewSymbol("ns"), false, true)

+ var VarOut = InternVarReplaceRoot(NSCore, NewSymbol("*out*"), os.Stdout).SetDynamic()

+ var VarParents = InternVarName(NSCore.Name(), NewSymbol("parents"))

+ var VarPrOn = InternVarName(NSCore.Name(), NewSymbol("pr-on"))

+ var VarPrintInitialized = InternVarName(NSCore.Name(), NewSymbol("print-initialized"))

+ var VarPrintReadably = InternVarReplaceRoot(NSCore, NewSymbol("*print-readably*"), true).SetDynamic()

+ var VarUncheckedMath = InternVarReplaceRoot(NSCore, NewSymbol("*unchecked-math*"), false).SetDynamic()

+ var VarWarnOnReflection = InternVarReplaceRoot(NSCore, NewSymbol("*warn-on-reflection*"), false).SetDynamic()

+ func Abs(x any) any

+ func Add(x, y any) any

+ func AddP(x, y any) any

+ func AppendWriter(w io.Writer, v interface{}) io.Writer

+ func Apply(fn interface{}, args []interface{}) interface

+ func AsByte(x any) byte

+ func AsFloat64(x any) float64

+ func AsInt(v any) (int, bool)

+ func AsInt64(x any) int64

+ func AsNumber(v any) (any, bool)

+ func BooleanCast(x any) bool

+ func ByteCast(x any) byte

+ func CharLiteralFromRune(rn rune) string

+ func CloneThreadBindingFrame() interface

+ func ConcatStrings(strs ...string) string

+ func Count(coll any) int

+ func CreatePersistentHashMap(keyvals any) any

+ func CreatePersistentTreeMap(keyvals interface{}) interface

+ func CreatePersistentTreeSet(keys ISeq) interface

+ func CreatePersistentTreeSetWithComparator(comparator IFn, keys ISeq) interface

+ func Dissoc(x any, k any) any

+ func Divide(x, y any) any

+ func Equals(a, b any) bool

+ func Equiv(a, b any) bool

+ func FieldOrMethod(v interface{}, name string) (interface{}, bool)

+ func First(x interface{}) interface

+ func FloatCast(x any) float32

+ func GT(x, y any) bool

+ func Get(coll, key any) any

+ func GetDefault(coll, key, def any) any

+ func GoAppend(slc interface{}, vals ...interface{}) interface

+ func GoCap(v interface{}) int

+ func GoChanOf(typ reflect.Type) reflect.Type

+ func GoClose(c interface{})

+ func GoComplex(real, imag interface{}) interface

+ func GoCopy(dst, src interface{}) int

+ func GoDelete(m, key interface{})

+ func GoDeref(ptr interface{}) interface

+ func GoImag(c interface{}) interface

+ func GoIndex(slc, i interface{}) interface

+ func GoLen(v interface{}) int

+ func GoMake(typ reflect.Type, args ...interface{}) interface

+ func GoMapIndex(m, k interface{}) interface

+ func GoNew(typ reflect.Type) interface

+ func GoPanic(v interface{})

+ func GoReal(c interface{}) interface

+ func GoRecv(ch interface{}) (interface{}, bool)

+ func GoRecvChanOf(typ reflect.Type) reflect.Type

+ func GoSend(ch, val interface{})

+ func GoSendChanOf(typ reflect.Type) reflect.Type

+ func GoSetMapIndex(m, k, v interface{})

+ func GoSlice(slc interface{}, indices ...interface{}) interface

+ func HasType(t reflect.Type, v interface{}) bool

+ func Hash(x interface{}) uint32

+ func HashEq(x any) uint32

+ func Identical(a, b any) bool

+ func IdentityHash(x interface{}) uint32

+ func Import(args ...interface{})

+ func Inc(v any) any

+ func IncP(v any) any

+ func IntCast(x any) int

+ func IsInteger(v any) bool

+ func IsNaN(x any) bool

+ func IsNil(v interface{}) bool

+ func IsNumber(x any) bool

+ func IsReduced(v interface{}) bool

+ func IsSeq(x interface{}) bool

+ func IsTruthy(v interface{}) bool

+ func IsZero(x any) bool

+ func LT(x, y any) bool

+ func LongCast(x any) int64

+ func Max(x, y any) any

+ func Min(x, y any) any

+ func Multiply(x, y any) any

+ func MustAsInt(v any) int

+ func MustAsNumber(v any) any

+ func MustNth(x interface{}, i int) interface

+ func NewArithmeticError(msg string) error

+ func NewIllegalArgumentError(msg string) error

+ func NewIllegalStateError(msg string) error

+ func NewIndexOutOfBoundsError() error

+ func NewTimeoutError(msg string) error

+ func Nth(x interface{}, n int) (interface{}, bool)

+ func NumbersEqual(x, y any) bool

+ func Ops(x any) ops

+ func Peek(stk IPersistentStack) interface

+ func PopThreadBindings()

+ func Print(x interface{}, w io.Writer)

+ func PrintString(v interface{}) string

+ func PushThreadBindings(bindings IPersistentMap)

+ func Reduce(f func(interface{}, interface{}) interface{}, seq ISeq) interface

+ func ReduceInit(f func(interface{}, interface{}) interface{}, init interface{}, seq ISeq) interface

+ func ReduceKV(f func(init, k, v interface{}) interface{}, init, coll interface{}) interface

+ func RemoveNamespace(sym *Symbol)

+ func ResetThreadBindingFrame(frame interface{})

+ func Rest(x interface{}) interface

+ func RuneFromCharLiteral(lit string) (rune, error)

+ func SetField(target interface{}, name string, val interface{}) error

+ func ShortCast(x any) int16

+ func ShutdownAgents()

+ func SliceSet(slc any, idx int, val any)

+ func Sub(x, y any) any

+ func SubP(x, y any) any

+ func ToSlice(x any) []any

+ func ToString(v interface{}) string

+ func TypeOf(v interface{}) reflect.Type

+ func UncheckedByteCast(x any) byte

+ func UncheckedFloatCast(x any) float32

+ func UncheckedIntCast(x any) int

+ func UncheckedLongCast(x any) int64

+ func UncheckedShortCast(x any) int16

+ func WithMeta(v any, meta IPersistentMap) (any, error)

+ func WriteWriter(w io.Writer, v interface{}) io.Writer

+ type AFn interface

+ type AMapEntry interface

+ type APersistentMap interface

+ type APersistentSet interface

+ type APersistentVector interface

+ type ASeq interface

+ Empty func() IPersistentCollection

+ String func() string

+ type Agent struct

+ type ArithmeticError struct

+ func (e *ArithmeticError) Error() string

+ func (e *ArithmeticError) Is(other error) bool

+ type ArrayNode struct

+ type ArrayNodeIterator struct

+ func (iter *ArrayNodeIterator) HasNext() bool

+ func (iter *ArrayNodeIterator) Next() *Pair

+ type ArrayNodeSeq struct

+ func (s *ArrayNodeSeq) Cons(obj any) Conser

+ func (s *ArrayNodeSeq) Count() int

+ func (s *ArrayNodeSeq) Empty() IPersistentCollection

+ func (s *ArrayNodeSeq) Equals(obj any) bool

+ func (s *ArrayNodeSeq) Equiv(obj any) bool

+ func (s *ArrayNodeSeq) First() any

+ func (s *ArrayNodeSeq) Hash() uint32

+ func (s *ArrayNodeSeq) HashEq() uint32

+ func (s *ArrayNodeSeq) Meta() IPersistentMap

+ func (s *ArrayNodeSeq) More() ISeq

+ func (s *ArrayNodeSeq) Next() ISeq

+ func (s *ArrayNodeSeq) Seq() ISeq

+ func (s *ArrayNodeSeq) String() string

+ func (s *ArrayNodeSeq) WithMeta(meta IPersistentMap) any

+ type Associative interface

+ Assoc func(k, v any) Associative

+ ContainsKey func(any) bool

+ EntryAt func(any) IMapEntry

+ func Assoc(a any, k, v any) Associative

+ type Atom struct

+ func NewAtom(val interface{}) *Atom

+ func (a *Atom) AddWatch(key interface{}, fn IFn)

+ func (a *Atom) CompareAndSet(oldv, newv interface{}) bool

+ func (a *Atom) Deref() interface{}

+ func (a *Atom) RemoveWatch(key interface{})

+ func (a *Atom) Reset(newVal interface{}) interface{}

+ func (a *Atom) SetValidator(vf IFn)

+ func (a *Atom) Swap(f IFn, args ISeq) interface{}

+ func (a *Atom) Validator() IFn

+ func (a *Atom) Watches() IPersistentMap

+ type BigDecimal struct

+ func AsBigDecimal(x any) *BigDecimal

+ func NewBigDecimal(s string) (*BigDecimal, error)

+ func NewBigDecimalFromBigFloat(x *big.Float) *BigDecimal

+ func NewBigDecimalFromFloat64(x float64) *BigDecimal

+ func NewBigDecimalFromInt64(x int64) *BigDecimal

+ func (n *BigDecimal) Abs() *BigDecimal

+ func (n *BigDecimal) Add(other *BigDecimal) *BigDecimal

+ func (n *BigDecimal) AddInt(x int) *BigDecimal

+ func (n *BigDecimal) AddP(other *BigDecimal) *BigDecimal

+ func (n *BigDecimal) Cmp(other *BigDecimal) int

+ func (n *BigDecimal) Divide(other *BigDecimal) *BigDecimal

+ func (n *BigDecimal) Equals(v interface{}) bool

+ func (n *BigDecimal) GT(other *BigDecimal) bool

+ func (n *BigDecimal) GTE(other *BigDecimal) bool

+ func (n *BigDecimal) Hash() uint32

+ func (n *BigDecimal) LT(other *BigDecimal) bool

+ func (n *BigDecimal) LTE(other *BigDecimal) bool

+ func (n *BigDecimal) Multiply(other *BigDecimal) *BigDecimal

+ func (n *BigDecimal) Negate() *BigDecimal

+ func (n *BigDecimal) Quotient(other *BigDecimal) *BigDecimal

+ func (n *BigDecimal) Remainder(other *BigDecimal) *BigDecimal

+ func (n *BigDecimal) String() string

+ func (n *BigDecimal) Sub(other *BigDecimal) *BigDecimal

+ func (n *BigDecimal) SubP(other *BigDecimal) *BigDecimal

+ func (n *BigDecimal) ToBigInteger() *big.Int

+ type BigInt struct

+ func AsBigInt(x any) *BigInt

+ func NewBigInt(s string) (*BigInt, error)

+ func NewBigIntFromGoBigInt(x *big.Int) *BigInt

+ func NewBigIntFromInt64(x int64) *BigInt

+ func NewBigIntWithBase(s string, base int) (*BigInt, error)

+ func (n *BigInt) Abs() *BigInt

+ func (n *BigInt) Add(other *BigInt) *BigInt

+ func (n *BigInt) AddInt(x int) *BigInt

+ func (n *BigInt) Cmp(other *BigInt) int

+ func (n *BigInt) Divide(other *BigInt) any

+ func (n *BigInt) Equals(v interface{}) bool

+ func (n *BigInt) GT(other *BigInt) bool

+ func (n *BigInt) GTE(other *BigInt) bool

+ func (n *BigInt) Hash() uint32

+ func (n *BigInt) Int64() int64

+ func (n *BigInt) IsInt64() bool

+ func (n *BigInt) LT(other *BigInt) bool

+ func (n *BigInt) LTE(other *BigInt) bool

+ func (n *BigInt) Multiply(other *BigInt) *BigInt

+ func (n *BigInt) Quotient(other *BigInt) *BigInt

+ func (n *BigInt) Remainder(other *BigInt) *BigInt

+ func (n *BigInt) String() string

+ func (n *BigInt) Sub(other *BigInt) *BigInt

+ func (n *BigInt) ToBigDecimal() *BigDecimal

+ func (n *BigInt) ToBigInteger() *big.Int

+ type BitmapIndexedNode struct

+ type Box struct

+ func NewBox(val interface{}) *Box

+ type Category int

+ type Char rune

+ func CharAt(s string, idx int) Char

+ func CharCast(x any) Char

+ func NewChar(value rune) Char

+ func UncheckedCharCast(x any) Char

+ func (c Char) Equals(v interface{}) bool

+ func (c Char) Hash() uint32

+ type ChunkBuffer struct

+ func NewChunkBuffer(capacity int) *ChunkBuffer

+ func (cb *ChunkBuffer) Add(item interface{})

+ func (cb *ChunkBuffer) Chunk() IChunk

+ func (cb *ChunkBuffer) Count() int

+ type ChunkedCons struct

+ func NewChunkedCons(chunk IChunk, more ISeq) *ChunkedCons

+ func (c *ChunkedCons) ChunkedFirst() IChunk

+ func (c *ChunkedCons) ChunkedMore() ISeq

+ func (c *ChunkedCons) ChunkedNext() ISeq

+ func (c *ChunkedCons) Cons(o any) Conser

+ func (c *ChunkedCons) Count() int

+ func (c *ChunkedCons) Empty() IPersistentCollection

+ func (c *ChunkedCons) Equals(o any) bool

+ func (c *ChunkedCons) Equiv(o any) bool

+ func (c *ChunkedCons) First() any

+ func (c *ChunkedCons) Hash() uint32

+ func (c *ChunkedCons) HashEq() uint32

+ func (c *ChunkedCons) Meta() IPersistentMap

+ func (c *ChunkedCons) More() ISeq

+ func (c *ChunkedCons) Next() ISeq

+ func (c *ChunkedCons) Seq() ISeq

+ func (c *ChunkedCons) String() string

+ func (c *ChunkedCons) WithMeta(meta IPersistentMap) any

+ type Comparer interface

+ Compare func(other any) int

+ type Conjer interface

+ Conj func(any) Conjer

+ type Cons struct

+ func (c *Cons) Cons(o any) Conser

+ func (c *Cons) Count() int

+ func (c *Cons) Empty() IPersistentCollection

+ func (c *Cons) Equals(o any) bool

+ func (c *Cons) Equiv(o any) bool

+ func (c *Cons) First() any

+ func (c *Cons) Hash() uint32

+ func (c *Cons) HashEq() uint32

+ func (c *Cons) Meta() IPersistentMap

+ func (c *Cons) More() ISeq

+ func (c *Cons) Next() ISeq

+ func (c *Cons) Seq() ISeq

+ func (c *Cons) String() string

+ func (c *Cons) WithMeta(meta IPersistentMap) any

+ type Conser interface

+ Cons func(any) Conser

+ func Conj(coll Conser, x any) Conser

+ type Counted interface

+ Count func() int

+ type Cycle struct

+ func (c *Cycle) Cons(o any) Conser

+ func (c *Cycle) Count() int

+ func (c *Cycle) Empty() IPersistentCollection

+ func (c *Cycle) Equals(o any) bool

+ func (c *Cycle) Equiv(o any) bool

+ func (c *Cycle) First() interface{}

+ func (c *Cycle) Hash() uint32

+ func (c *Cycle) HashEq() uint32

+ func (c *Cycle) IsRealized() bool

+ func (c *Cycle) Meta() IPersistentMap

+ func (c *Cycle) More() ISeq

+ func (c *Cycle) Next() ISeq

+ func (c *Cycle) Reduce(f IFn) interface{}

+ func (c *Cycle) ReduceInit(f IFn, init interface{}) interface{}

+ func (c *Cycle) Seq() ISeq

+ func (c *Cycle) String() string

+ func (c *Cycle) WithMeta(meta IPersistentMap) interface{}

+ type EmptyList struct

+ func (e *EmptyList) Cons(x any) Conser

+ func (e *EmptyList) Count() int

+ func (e *EmptyList) Empty() IPersistentCollection

+ func (e *EmptyList) Equals(other any) bool

+ func (e *EmptyList) Equiv(other any) bool

+ func (e *EmptyList) First() any

+ func (e *EmptyList) Hash() uint32

+ func (e *EmptyList) HashEq() uint32

+ func (e *EmptyList) IsEmpty() bool

+ func (e *EmptyList) Meta() IPersistentMap

+ func (e *EmptyList) More() ISeq

+ func (e *EmptyList) Next() ISeq

+ func (e *EmptyList) Peek() any

+ func (e *EmptyList) Pop() IPersistentStack

+ func (e *EmptyList) Reduce(f IFn) any

+ func (e *EmptyList) ReduceInit(f IFn, init any) any

+ func (e *EmptyList) Seq() ISeq

+ func (e *EmptyList) String() string

+ func (e *EmptyList) WithMeta(meta IPersistentMap) any

+ type EmptyMapIterator struct

+ type Environment interface

+ BindLocal func(sym *Symbol, v interface{})

+ Context func() context.Context

+ CurrentNamespace func() *Namespace

+ DefVar func(sym *Symbol, v interface{}) *Var

+ Errorf func(form interface{}, format string, args ...interface{}) error

+ Eval func(expr interface{}) (interface{}, error)

+ EvalAST func(n interface{}) (interface{}, error)

+ PushLoadPaths func(paths []string) Environment

+ PushScope func() Environment

+ ResolveFile func(path string) (string, bool)

+ SetCurrentNamespace func(ns *Namespace)

+ Stderr func() io.Writer

+ Stdout func() io.Writer

+ WithRecurTarget func(target interface{}) Environment

+ var GlobalEnv Environment

+ type Equalser interface

+ Equals func(any) bool

+ type Equiver interface

+ Equiv func(any) bool

+ type Error struct

+ func NewError(frame StackFrame, err error) *Error

+ func (e *Error) AddStack(frame StackFrame) error

+ func (e *Error) Error() string

+ func (e *Error) Stack() []StackFrame

+ func (e *Error) Unwrap() error

+ type Future interface

+ Get func() any

+ GetWithTimeout func(timeout int64, timeUnit time.Duration) any

+ type GoMapSeq struct

+ func NewGoMapSeq(gm any) *GoMapSeq

+ func (s *GoMapSeq) Cons(o any) Conser

+ func (s *GoMapSeq) Count() int

+ func (s *GoMapSeq) Empty() IPersistentCollection

+ func (s *GoMapSeq) Equals(o any) bool

+ func (s *GoMapSeq) Equiv(o any) bool

+ func (s *GoMapSeq) First() any

+ func (s *GoMapSeq) Hash() uint32

+ func (s *GoMapSeq) HashEq() uint32

+ func (s *GoMapSeq) KVReduce(f IFn, init any) any

+ func (s *GoMapSeq) Meta() IPersistentMap

+ func (s *GoMapSeq) More() ISeq

+ func (s *GoMapSeq) Next() ISeq

+ func (s *GoMapSeq) Reduce(f IFn) any

+ func (s *GoMapSeq) ReduceInit(f IFn, init any) any

+ func (s *GoMapSeq) Seq() ISeq

+ func (s *GoMapSeq) String() string

+ func (s *GoMapSeq) WithMeta(meta IPersistentMap) any

+ type HashCollisionNode struct

+ type Hasher interface

+ Hash func() uint32

+ type IAtom interface

+ CompareAndSet func(oldv, newv any) bool

+ Reset func(newVal any) any

+ Swap func(f IFn, args ISeq) any

+ type IAtom2 interface

+ type IBlockingDeref interface

+ DerefWithTimeout func(timeoutMS int64, timeoutVal any) any

+ func AgentSubmit(fn IFn) IBlockingDeref

+ type IChunk interface

+ DropFirst func() IChunk

+ ReduceInit func(fn IFn, init any) any

+ type IChunkedSeq interface

+ ChunkedFirst func() IChunk

+ ChunkedMore func() ISeq

+ ChunkedNext func() ISeq

+ type IDeref interface

+ Deref func() any

+ type IDrop interface

+ Drop func(n int) Sequential

+ type IEditableCollection interface

+ AsTransient func() ITransientCollection

+ type IFn interface

+ ApplyTo func(args ISeq) any

+ Invoke func(args ...any) any

+ type IFnFunc func(args ...interface{}) interface

+ func (f IFnFunc) ApplyTo(args ISeq) interface{}

+ func (f IFnFunc) Invoke(args ...interface{}) interface{}

+ type IHashEq interface

+ HashEq func() uint32

+ type IKVReduce interface

+ KVReduce func(f IFn, init any) any

+ type ILookup interface

+ ValAt func(any) any

+ ValAtDefault func(any, any) any

+ type IMapEntry interface

+ Key func() any

+ Val func() any

+ type IMeta interface

+ Meta func() IPersistentMap

+ type IObj interface

+ WithMeta func(meta IPersistentMap) any

+ type IPending interface

+ IsRealized func() bool

+ type IPersistentCollection interface

+ Empty func() IPersistentCollection

+ Equiv func(any) bool

+ type IPersistentList interface

+ func NewList(values ...any) IPersistentList

+ type IPersistentMap interface

+ AssocEx func(key, val any) IPersistentMap

+ Without func(key any) IPersistentMap

+ func Merge(m1, m2 IPersistentMap) IPersistentMap

+ func NewMap(keyVals ...any) IPersistentMap

+ func NewPersistentArrayMapAsIfByAssoc(init []any) IPersistentMap

+ func NewPersistentHashMap(keyvals ...any) IPersistentMap

+ func SafeMerge(m1, m2 IPersistentMap) IPersistentMap

+ type IPersistentSet interface

+ Contains func(any) bool

+ Disjoin func(any) IPersistentSet

+ Get func(any) any

+ type IPersistentStack interface

+ Peek func() any

+ Pop func() IPersistentStack

+ func Pop(stk IPersistentStack) IPersistentStack

+ type IPersistentVector interface

+ AssocN func(int, any) IPersistentVector

+ Cons func(any) Conser

+ Length func() int

+ func CreateLazilyPersistentVector(obj any) IPersistentVector

+ func CreateOwningLazilyPersistentVector(items any) IPersistentVector

+ func Subvec(v IPersistentVector, start, end int) IPersistentVector

+ type IRecord interface

+ type IReduce interface

+ Reduce func(f IFn) any

+ type IReduceInit interface

+ ReduceInit func(f IFn, init any) any

+ type IRef interface

+ AddWatch func(key any, fn IFn)

+ RemoveWatch func(key any)

+ SetValidator func(vf IFn)

+ Validator func() IFn

+ Watches func() IPersistentMap

+ type ISeq interface

+ First func() any

+ More func() ISeq

+ Next func() ISeq

+ func Keys(m Associative) ISeq

+ func NewCons(x any, xs any) ISeq

+ func NewCycle(vals ISeq) ISeq

+ func NewLazySeq(fn func() interface{}) ISeq

+ func NewLongRange(start, end, step int64) (res ISeq)

+ func NewMapKeySeq(s ISeq) ISeq

+ func NewMapValSeq(s ISeq) ISeq

+ func NewRange(start, end, step any) ISeq

+ func NewRepeatN(count int64, x interface{}) ISeq

+ func NewSliceSeq(x any) ISeq

+ func Next(x interface{}) ISeq

+ func Seq(x interface{}) ISeq

+ func Vals(m Associative) ISeq

+ type ITransientAssociative interface

+ Assoc func(any, any) ITransientAssociative

+ type ITransientCollection interface

+ Persistent func() IPersistentCollection

+ type ITransientSet interface

+ Contains func(any) bool

+ Disjoin func(any) ITransientSet

+ Get func(any) any

+ type ITransientVector interface

+ AssocN func(int, any) ITransientVector

+ Pop func() ITransientVector

+ type IllegalArgumentError struct

+ func (e *IllegalArgumentError) Error() string

+ func (e *IllegalArgumentError) Is(other error) bool

+ type IllegalStateError struct

+ func (e *IllegalStateError) Error() string

+ func (e *IllegalStateError) Is(other error) bool

+ type IndexOutOfBoundsError struct

+ func (e *IndexOutOfBoundsError) Error() string

+ func (e *IndexOutOfBoundsError) Is(other error) bool

+ type Indexed interface

+ Nth func(int) any

+ NthDefault func(int, any) any

+ type IndexedSeq interface

+ Index func() int

+ type Keyword struct

+ func InternKeyword(ns, name interface{}) Keyword

+ func InternKeywordString(s string) Keyword

+ func InternKeywordSymbol(s *Symbol) Keyword

+ func NewKeyword(s string) Keyword

+ func (k Keyword) ApplyTo(args ISeq) interface{}

+ func (k Keyword) Equals(v interface{}) bool

+ func (k Keyword) Hash() uint32

+ func (k Keyword) Invoke(args ...interface{}) interface{}

+ func (k Keyword) Name() string

+ func (k Keyword) Namespace() string

+ func (k Keyword) String() string

+ type LazySeq struct

+ func (s *LazySeq) Cons(x interface{}) Conser

+ func (s *LazySeq) Count() int

+ func (s *LazySeq) Empty() IPersistentCollection

+ func (s *LazySeq) Equals(o interface{}) bool

+ func (s *LazySeq) Equiv(o interface{}) bool

+ func (s *LazySeq) First() interface{}

+ func (s *LazySeq) Hash() uint32

+ func (s *LazySeq) HashEq() uint32

+ func (s *LazySeq) IsRealized() bool

+ func (s *LazySeq) Meta() IPersistentMap

+ func (s *LazySeq) More() ISeq

+ func (s *LazySeq) Next() ISeq

+ func (s *LazySeq) Seq() ISeq

+ func (s *LazySeq) String() string

+ func (s *LazySeq) WithMeta(meta IPersistentMap) interface{}

+ type List struct

+ func ConsList(item any, next *List) *List

+ func (l *List) Cons(x any) Conser

+ func (l *List) Count() int

+ func (l *List) Empty() IPersistentCollection

+ func (l *List) Equals(other any) bool

+ func (l *List) Equiv(other any) bool

+ func (l *List) First() any

+ func (l *List) Hash() uint32

+ func (l *List) HashEq() uint32

+ func (l *List) IsEmpty() bool

+ func (l *List) Item() any

+ func (l *List) Meta() IPersistentMap

+ func (l *List) More() ISeq

+ func (l *List) Next() ISeq

+ func (l *List) Peek() any

+ func (l *List) Pop() IPersistentStack

+ func (l *List) Reduce(f IFn) any

+ func (l *List) ReduceInit(f IFn, init any) any

+ func (l *List) Seq() ISeq

+ func (l *List) String() string

+ func (l *List) WithMeta(meta IPersistentMap) any

+ type LockingTransactor struct

+ func (lt *LockingTransactor) RunInTransaction(fn IFn) interface{}

+ type LongChunk struct

+ func NewLongChunk(start, step int64, count int) *LongChunk

+ func (c *LongChunk) Count() int

+ func (c *LongChunk) DropFirst() IChunk

+ func (c *LongChunk) First() any

+ func (c *LongChunk) Nth(i int) any

+ func (c *LongChunk) NthDefault(i int, notFound any) any

+ func (c *LongChunk) ReduceInit(f IFn, init any) any

+ type LongRange struct

+ func (r *LongRange) ChunkedFirst() IChunk

+ func (r *LongRange) ChunkedMore() ISeq

+ func (r *LongRange) ChunkedNext() ISeq

+ func (r *LongRange) Cons(o any) Conser

+ func (r *LongRange) Count() int

+ func (r *LongRange) Drop(n int) Sequential

+ func (r *LongRange) Empty() IPersistentCollection

+ func (r *LongRange) Equals(o any) bool

+ func (r *LongRange) Equiv(o any) bool

+ func (r *LongRange) First() any

+ func (r *LongRange) Hash() uint32

+ func (r *LongRange) HashEq() uint32

+ func (r *LongRange) Meta() IPersistentMap

+ func (r *LongRange) More() ISeq

+ func (r *LongRange) Next() ISeq

+ func (r *LongRange) Reduce(f IFn) any

+ func (r *LongRange) ReduceInit(f IFn, init any) any

+ func (r *LongRange) Seq() ISeq

+ func (r *LongRange) String() string

+ func (r *LongRange) WithMeta(meta IPersistentMap) any

+ type Map struct

+ func (m *Map) ApplyTo(args ISeq) any

+ func (m *Map) AsTransient() ITransientCollection

+ func (m *Map) Assoc(k, v any) Associative

+ func (m *Map) AssocEx(k, v any) IPersistentMap

+ func (m *Map) Cons(x any) Conser

+ func (m *Map) ContainsKey(k any) bool

+ func (m *Map) Count() int

+ func (m *Map) Empty() IPersistentCollection

+ func (m *Map) EntryAt(k any) IMapEntry

+ func (m *Map) Equiv(o any) bool

+ func (m *Map) HashEq() uint32

+ func (m *Map) Invoke(args ...any) any

+ func (m *Map) Meta() IPersistentMap

+ func (m *Map) Reduce(f IFn) any

+ func (m *Map) ReduceInit(f IFn, init any) any

+ func (m *Map) Seq() ISeq

+ func (m *Map) String() string

+ func (m *Map) ValAt(key any) any

+ func (m *Map) ValAtDefault(key, def any) any

+ func (m *Map) WithMeta(meta IPersistentMap) any

+ func (m *Map) Without(k any) IPersistentMap

+ type MapEntry struct

+ func NewMapEntry(key, val any) *MapEntry

+ func (me *MapEntry) ApplyTo(args ISeq) any

+ func (me *MapEntry) Assoc(k, v any) Associative

+ func (me *MapEntry) AssocN(i int, o any) IPersistentVector

+ func (me *MapEntry) Cons(o any) Conser

+ func (me *MapEntry) ContainsKey(k any) bool

+ func (me *MapEntry) Count() int

+ func (me *MapEntry) Empty() IPersistentCollection

+ func (me *MapEntry) EntryAt(k any) IMapEntry

+ func (me *MapEntry) Equiv(o any) bool

+ func (me *MapEntry) GetKey() any

+ func (me *MapEntry) GetValue() any

+ func (me *MapEntry) HashEq() uint32

+ func (me *MapEntry) Invoke(args ...any) any

+ func (me *MapEntry) Key() any

+ func (me *MapEntry) Length() int

+ func (me *MapEntry) Nth(i int) any

+ func (me *MapEntry) NthDefault(i int, d any) any

+ func (me *MapEntry) Peek() any

+ func (me *MapEntry) Pop() IPersistentStack

+ func (me *MapEntry) RSeq() ISeq

+ func (me *MapEntry) Seq() ISeq

+ func (me *MapEntry) String() string

+ func (me *MapEntry) Val() any

+ func (me *MapEntry) ValAt(key any) any

+ func (me *MapEntry) ValAtDefault(key, notFound any) any

+ type MapIterator interface

+ HasNext func() bool

+ Next func() *Pair

+ type MapKeySeq struct

+ func (s *MapKeySeq) Cons(o any) Conser

+ func (s *MapKeySeq) Count() int

+ func (s *MapKeySeq) Empty() IPersistentCollection

+ func (s *MapKeySeq) Equals(o any) bool

+ func (s *MapKeySeq) Equiv(o any) bool

+ func (s *MapKeySeq) First() any

+ func (s *MapKeySeq) Hash() uint32

+ func (s *MapKeySeq) HashEq() uint32

+ func (s *MapKeySeq) Meta() IPersistentMap

+ func (s *MapKeySeq) More() ISeq

+ func (s *MapKeySeq) Next() ISeq

+ func (s *MapKeySeq) Seq() ISeq

+ func (s *MapKeySeq) String() string

+ func (s *MapKeySeq) WithMeta(meta IPersistentMap) any

+ type MapSeq struct

+ func NewMapSeq(kvs []any) *MapSeq

+ func (s *MapSeq) Cons(o any) Conser

+ func (s *MapSeq) Count() int

+ func (s *MapSeq) Drop(n int) Sequential

+ func (s *MapSeq) Empty() IPersistentCollection

+ func (s *MapSeq) Equals(o any) bool

+ func (s *MapSeq) Equiv(o any) bool

+ func (s *MapSeq) First() any

+ func (s *MapSeq) Hash() uint32

+ func (s *MapSeq) HashEq() uint32

+ func (s *MapSeq) Meta() IPersistentMap

+ func (s *MapSeq) More() ISeq

+ func (s *MapSeq) Next() ISeq

+ func (s *MapSeq) Reduce(f IFn) any

+ func (s *MapSeq) ReduceInit(f IFn, init any) any

+ func (s *MapSeq) Seq() ISeq

+ func (s *MapSeq) String() string

+ func (s *MapSeq) WithMeta(meta IPersistentMap) any

+ type MapValSeq struct

+ func (s *MapValSeq) Cons(o any) Conser

+ func (s *MapValSeq) Count() int

+ func (s *MapValSeq) Empty() IPersistentCollection

+ func (s *MapValSeq) Equals(o any) bool

+ func (s *MapValSeq) Equiv(o any) bool

+ func (s *MapValSeq) First() any

+ func (s *MapValSeq) Hash() uint32

+ func (s *MapValSeq) HashEq() uint32

+ func (s *MapValSeq) Meta() IPersistentMap

+ func (s *MapValSeq) More() ISeq

+ func (s *MapValSeq) Next() ISeq

+ func (s *MapValSeq) Reduce(f IFn) any

+ func (s *MapValSeq) ReduceInit(f IFn, init any) any

+ func (s *MapValSeq) Seq() ISeq

+ func (s *MapValSeq) String() string

+ func (s *MapValSeq) WithMeta(meta IPersistentMap) any

+ type MultiFn struct

+ func NewMultiFn(name string, dispatchFn IFn, defaultDispatchVal interface{}, hierarchy IRef) *MultiFn

+ func (m *MultiFn) AddMethod(dispatchVal interface{}, method IFn) *MultiFn

+ func (m *MultiFn) ApplyTo(args ISeq) interface{}

+ func (m *MultiFn) Invoke(args ...interface{}) interface{}

+ func (m *MultiFn) PreferMethod(dispatchValX, dispatchValY interface{}) *MultiFn

+ func (m *MultiFn) PreferTable() IPersistentMap

+ type Named interface

+ Name func() string

+ Namespace func() string

+ type Namespace struct

+ func FindNamespace(sym *Symbol) *Namespace

+ func FindOrCreateNamespace(sym *Symbol) *Namespace

+ func NamespaceFor(inns *Namespace, sym *Symbol) *Namespace

+ func Namespaces() []*Namespace

+ func NewNamespace(name *Symbol) *Namespace

+ func (ns *Namespace) AddAlias(alias *Symbol, ns2 *Namespace)

+ func (ns *Namespace) Aliases() IPersistentMap

+ func (ns *Namespace) AlterMeta(alter IFn, args ISeq) IPersistentMap

+ func (ns *Namespace) FindInternedVar(sym *Symbol) *Var

+ func (ns *Namespace) GetMapping(sym *Symbol) interface{}

+ func (ns *Namespace) Import(export string, v interface{}) interface{}

+ func (ns *Namespace) Intern(sym *Symbol) *Var

+ func (ns *Namespace) InternWithValue(sym *Symbol, value interface{}, replaceRoot bool) *Var

+ func (ns *Namespace) LookupAlias(sym *Symbol) *Namespace

+ func (ns *Namespace) Mappings() IPersistentMap

+ func (ns *Namespace) Meta() IPersistentMap

+ func (ns *Namespace) Name() *Symbol

+ func (ns *Namespace) Refer(sym *Symbol, v *Var) *Var

+ func (ns *Namespace) ResetMeta(meta IPersistentMap) IPersistentMap

+ func (ns *Namespace) String() string

+ type Node interface

+ type NodeIterator struct

+ func (iter *NodeIterator) HasNext() bool

+ func (iter *NodeIterator) Next() *Pair

+ type NodeSeq struct

+ func (n *NodeSeq) Meta() IPersistentMap

+ func (s *NodeSeq) Cons(obj any) Conser

+ func (s *NodeSeq) Count() int

+ func (s *NodeSeq) Empty() IPersistentCollection

+ func (s *NodeSeq) Equals(obj any) bool

+ func (s *NodeSeq) Equiv(obj any) bool

+ func (s *NodeSeq) First() any

+ func (s *NodeSeq) Hash() uint32

+ func (s *NodeSeq) HashEq() uint32

+ func (s *NodeSeq) More() ISeq

+ func (s *NodeSeq) Next() ISeq

+ func (s *NodeSeq) Seq() ISeq

+ func (s *NodeSeq) String() string

+ func (s *NodeSeq) WithMeta(meta IPersistentMap) any

+ type Nther interface

+ Nth func(int) (v interface{}, ok bool)

+ type NumberMethods struct

+ func (nm *NumberMethods) Add(x, y any) any

+ func (nm *NumberMethods) AddP(x, y any) any

+ func (nm *NumberMethods) And(x, y any) any

+ func (nm *NumberMethods) BooleanArray(sizeOrSeq any) []bool

+ func (nm *NumberMethods) BooleanArrayInit(size int, init any) []bool

+ func (nm *NumberMethods) Booleans(x any) []bool

+ func (nm *NumberMethods) ByteArray(sizeOrSeq any) []byte

+ func (nm *NumberMethods) ByteArrayInit(size int, init any) []byte

+ func (nm *NumberMethods) Bytes(x any) []byte

+ func (nm *NumberMethods) CharArray(sizeOrSeq any) []Char

+ func (nm *NumberMethods) CharArrayInit(size int, init any) []Char

+ func (nm *NumberMethods) Chars(x any) []Char

+ func (nm *NumberMethods) ClearBit(x, y any) int64

+ func (nm *NumberMethods) Dec(x any) any

+ func (nm *NumberMethods) Divide(x, y any) any

+ func (nm *NumberMethods) DoubleArray(sizeOrSeq any) []float64

+ func (nm *NumberMethods) DoubleArrayInit(size int, init any) []float64

+ func (nm *NumberMethods) Doubles(x any) []float64

+ func (nm *NumberMethods) Equiv(x, y any) bool

+ func (nm *NumberMethods) FlipBit(x, y any) int64

+ func (nm *NumberMethods) FloatArray(sizeOrSeq any) []float32

+ func (nm *NumberMethods) FloatArrayInit(size int, init any) []float32

+ func (nm *NumberMethods) Floats(x any) []float32

+ func (nm *NumberMethods) Gt(x, y any) bool

+ func (nm *NumberMethods) Gte(x, y any) bool

+ func (nm *NumberMethods) Inc(v any) any

+ func (nm *NumberMethods) IntArray(sizeOrSeq any) []int

+ func (nm *NumberMethods) IntArrayInit(size int, init any) []int

+ func (nm *NumberMethods) Ints(x any) []int

+ func (nm *NumberMethods) IsNeg(x any) bool

+ func (nm *NumberMethods) IsPos(x any) bool

+ func (nm *NumberMethods) IsZero(x any) bool

+ func (nm *NumberMethods) LongArray(sizeOrSeq any) []int64

+ func (nm *NumberMethods) LongArrayInit(size int, init any) []int64

+ func (nm *NumberMethods) Longs(x any) []int64

+ func (nm *NumberMethods) Lt(x, y any) bool

+ func (nm *NumberMethods) Lte(x, y any) bool

+ func (nm *NumberMethods) Max(x, y any) any

+ func (nm *NumberMethods) Min(x, y any) any

+ func (nm *NumberMethods) Minus(x, y any) any

+ func (nm *NumberMethods) MinusP(x, y any) any

+ func (nm *NumberMethods) Multiply(x, y any) any

+ func (nm *NumberMethods) MultiplyP(x, y any) any

+ func (nm *NumberMethods) Quotient(x, y any) any

+ func (nm *NumberMethods) Remainder(x, y any) any

+ func (nm *NumberMethods) SetBit(x, y any) int64

+ func (nm *NumberMethods) ShiftLeft(x, y any) int64

+ func (nm *NumberMethods) ShiftRight(x, y any) int64

+ func (nm *NumberMethods) ShortArray(sizeOrSeq any) []int16

+ func (nm *NumberMethods) ShortArrayInit(size int, init any) []int16

+ func (nm *NumberMethods) Shorts(x any) []int16

+ func (nm *NumberMethods) TestBit(x, y any) bool

+ func (nm *NumberMethods) UncheckedAdd(x, y any) any

+ func (nm *NumberMethods) UncheckedDec(x any) any

+ func (nm *NumberMethods) UncheckedIntDivide(x, y int) any

+ func (nm *NumberMethods) Unchecked_inc(v any) any

+ func (nm *NumberMethods) Unchecked_minus(x, y any) any

+ func (nm *NumberMethods) Unchecked_multiply(x, y any) any

+ func (nm *NumberMethods) Unchecked_negate(x any) any

+ func (nm *NumberMethods) UnsignedShiftRight(x, y any) int64

+ type Object any

+ type Pair struct

+ Key any

+ Value any

+ type PersistentHashMap struct

+ func (m *PersistentHashMap) ApplyTo(args ISeq) any

+ func (m *PersistentHashMap) Assoc(key, val any) Associative

+ func (m *PersistentHashMap) AssocEx(key, val any) IPersistentMap

+ func (m *PersistentHashMap) Cons(o any) Conser

+ func (m *PersistentHashMap) ContainsKey(k any) bool

+ func (m *PersistentHashMap) Count() int

+ func (m *PersistentHashMap) Empty() IPersistentCollection

+ func (m *PersistentHashMap) EntryAt(key any) IMapEntry

+ func (m *PersistentHashMap) Equiv(o any) bool

+ func (m *PersistentHashMap) HashEq() uint32

+ func (m *PersistentHashMap) Invoke(args ...any) any

+ func (m *PersistentHashMap) Meta() IPersistentMap

+ func (m *PersistentHashMap) Reduce(f IFn) any

+ func (m *PersistentHashMap) ReduceInit(f IFn, init any) any

+ func (m *PersistentHashMap) Seq() ISeq

+ func (m *PersistentHashMap) String() string

+ func (m *PersistentHashMap) ValAt(key any) any

+ func (m *PersistentHashMap) ValAtDefault(key, notFound any) any

+ func (m *PersistentHashMap) WithMeta(meta IPersistentMap) any

+ func (m *PersistentHashMap) Without(key any) IPersistentMap

+ type PersistentHashSet = Set

+ type PersistentStructMap struct

+ func ConstructPersistentStructMap(def *PersistentStructMapDef, valseq ISeq) *PersistentStructMap

+ func (m *PersistentStructMap) ApplyTo(args ISeq) any

+ func (m *PersistentStructMap) Assoc(k any, v any) Associative

+ func (m *PersistentStructMap) AssocEx(k, v any) IPersistentMap

+ func (m *PersistentStructMap) Cons(x any) Conser

+ func (m *PersistentStructMap) ContainsKey(k any) bool

+ func (m *PersistentStructMap) Count() int

+ func (m *PersistentStructMap) Empty() IPersistentCollection

+ func (m *PersistentStructMap) EntryAt(k any) IMapEntry

+ func (m *PersistentStructMap) Equiv(o any) bool

+ func (m *PersistentStructMap) HashEq() uint32

+ func (m *PersistentStructMap) Invoke(args ...any) any

+ func (m *PersistentStructMap) Meta() IPersistentMap

+ func (m *PersistentStructMap) Seq() ISeq

+ func (m *PersistentStructMap) ValAt(key any) any

+ func (m *PersistentStructMap) ValAtDefault(key, def any) any

+ func (m *PersistentStructMap) WithMeta(meta IPersistentMap) any

+ func (m *PersistentStructMap) Without(k any) IPersistentMap

+ type PersistentStructMapDef struct

+ func CreatePersistentStructMapSlotMap(keys ISeq) *PersistentStructMapDef

+ type PersistentVector = Vector

+ type Range struct

+ func (r *Range) ChunkedFirst() IChunk

+ func (r *Range) ChunkedMore() ISeq

+ func (r *Range) ChunkedNext() ISeq

+ func (r *Range) Cons(val any) Conser

+ func (r *Range) Count() int

+ func (r *Range) Empty() IPersistentCollection

+ func (r *Range) Equals(o any) bool

+ func (r *Range) Equiv(o any) bool

+ func (r *Range) First() any

+ func (r *Range) ForceChunk()

+ func (r *Range) Hash() uint32

+ func (r *Range) HashEq() uint32

+ func (r *Range) Meta() IPersistentMap

+ func (r *Range) More() ISeq

+ func (r *Range) Next() ISeq

+ func (r *Range) Reduce(f IFn) any

+ func (r *Range) ReduceInit(f IFn, init any) any

+ func (r *Range) Seq() ISeq

+ func (r *Range) String() string

+ func (r *Range) WithMeta(meta IPersistentMap) any

+ type Ratio struct

+ func AsRatio(x any) *Ratio

+ func NewRatio(numerator, denominator int64) *Ratio

+ func NewRatioBigInt(num, den *BigInt) *Ratio

+ func NewRatioGoBigInt(num, den *big.Int) *Ratio

+ func (r *Ratio) Abs() *Ratio

+ func (r *Ratio) Add(other *Ratio) any

+ func (r *Ratio) BigIntegerValue() *big.Int

+ func (r *Ratio) Cmp(other *Ratio) int

+ func (r *Ratio) Denominator() *big.Int

+ func (r *Ratio) Divide(other *Ratio) any

+ func (r *Ratio) Equals(other interface{}) bool

+ func (r *Ratio) GT(other *Ratio) bool

+ func (r *Ratio) GTE(other *Ratio) bool

+ func (r *Ratio) LT(other *Ratio) bool

+ func (r *Ratio) LTE(other *Ratio) bool

+ func (r *Ratio) Multiply(other *Ratio) any

+ func (r *Ratio) Negate() *Ratio

+ func (r *Ratio) Numerator() *big.Int

+ func (r *Ratio) Quotient(other *Ratio) any

+ func (r *Ratio) String() string

+ func (r *Ratio) Sub(other *Ratio) any

+ type RecurError struct

+ Args []interface{}

+ Target interface{}

+ func (e *RecurError) Error() string

+ func (e *RecurError) Is(err error) bool

+ type RecurTarget struct

+ func NewRecurTarget() *RecurTarget

+ type Reduced struct

+ func NewReduced(v interface{}) *Reduced

+ func (r *Reduced) Deref() interface{}

+ type Ref struct

+ func NewRef(val interface{}) *Ref

+ func (r *Ref) Commute(fn IFn, args ISeq) interface{}

+ func (r *Ref) Deref() interface{}

+ type RegexpMatcher struct

+ func NewRegexpMatcher(re *regexp.Regexp, s string) *RegexpMatcher

+ func (m *RegexpMatcher) AppendReplacement(sb io.Writer, replacement string) *RegexpMatcher

+ func (m *RegexpMatcher) AppendTail(sb io.Writer)

+ func (m *RegexpMatcher) Find() bool

+ func (m *RegexpMatcher) Group() string

+ func (m *RegexpMatcher) GroupCount() int

+ func (m *RegexpMatcher) GroupInt(group int) any

+ func (m *RegexpMatcher) Matches() bool

+ type Repeat struct

+ func NewRepeat(x interface{}) *Repeat

+ func (r *Repeat) Cons(val any) Conser

+ func (r *Repeat) Count() int

+ func (r *Repeat) Empty() IPersistentCollection

+ func (r *Repeat) Equals(o any) bool

+ func (r *Repeat) Equiv(o any) bool

+ func (r *Repeat) First() interface{}

+ func (r *Repeat) Hash() uint32

+ func (r *Repeat) HashEq() uint32

+ func (r *Repeat) Meta() IPersistentMap

+ func (r *Repeat) More() ISeq

+ func (r *Repeat) Next() ISeq

+ func (r *Repeat) Reduce(f IFn) interface{}

+ func (r *Repeat) ReduceInit(f IFn, start interface{}) interface{}

+ func (r *Repeat) Seq() ISeq

+ func (r *Repeat) String() string

+ func (r *Repeat) WithMeta(meta IPersistentMap) any

+ type Reversible interface

+ RSeq func() ISeq

+ type Seqable interface

+ Seq func() ISeq

+ type Sequential interface

+ type Set struct

+ func NewSet(vals ...interface{}) *Set

+ func (s *Set) ApplyTo(args ISeq) interface{}

+ func (s *Set) AsTransient() ITransientCollection

+ func (s *Set) Cons(v interface{}) Conser

+ func (s *Set) Contains(v interface{}) bool

+ func (s *Set) Count() int

+ func (s *Set) Disjoin(v interface{}) IPersistentSet

+ func (s *Set) Empty() IPersistentCollection

+ func (s *Set) Equals(v2 interface{}) bool

+ func (s *Set) Equiv(o any) bool

+ func (s *Set) Get(key interface{}) interface{}

+ func (s *Set) HashEq() uint32

+ func (s *Set) Invoke(args ...interface{}) interface{}

+ func (s *Set) IsEmpty() bool

+ func (s *Set) Meta() IPersistentMap

+ func (s *Set) Seq() ISeq

+ func (s *Set) String() string

+ func (s *Set) WithMeta(meta IPersistentMap) interface{}

+ type SliceChunk struct

+ func NewSliceChunk(slc []interface{}) *SliceChunk

+ func (sc *SliceChunk) Count() int

+ func (sc *SliceChunk) DropFirst() IChunk

+ func (sc *SliceChunk) Nth(i int) interface{}

+ func (sc *SliceChunk) NthDefault(i int, def interface{}) interface{}

+ func (sc *SliceChunk) ReduceInit(fn IFn, init interface{}) interface{}

+ type SliceSeq struct

+ func (s *SliceSeq) Cons(o any) Conser

+ func (s *SliceSeq) Count() int

+ func (s *SliceSeq) Empty() IPersistentCollection

+ func (s *SliceSeq) Equals(o any) bool

+ func (s *SliceSeq) Equiv(o any) bool

+ func (s *SliceSeq) First() any

+ func (s *SliceSeq) Hash() uint32

+ func (s *SliceSeq) HashEq() uint32

+ func (s *SliceSeq) Meta() IPersistentMap

+ func (s *SliceSeq) More() ISeq

+ func (s *SliceSeq) Next() ISeq

+ func (s *SliceSeq) Reduce(f IFn) any

+ func (s *SliceSeq) ReduceInit(f IFn, start any) any

+ func (s *SliceSeq) Seq() ISeq

+ func (s *SliceSeq) String() string

+ func (s *SliceSeq) WithMeta(meta IPersistentMap) any

+ type StackFrame struct

+ Column int

+ Filename string

+ FunctionName string

+ Line int

+ type Stacker interface

+ Stack func() []StackFrame

+ type StringSeq struct

+ func NewStringSeq(s string, i int) *StringSeq

+ func (s *StringSeq) Cons(o any) Conser

+ func (s *StringSeq) Count() int

+ func (s *StringSeq) Drop(n int) Sequential

+ func (s *StringSeq) Empty() IPersistentCollection

+ func (s *StringSeq) Equals(o any) bool

+ func (s *StringSeq) Equiv(o any) bool

+ func (s *StringSeq) First() any

+ func (s *StringSeq) Hash() uint32

+ func (s *StringSeq) HashEq() uint32

+ func (s *StringSeq) Index() int

+ func (s *StringSeq) Meta() IPersistentMap

+ func (s *StringSeq) More() ISeq

+ func (s *StringSeq) Next() ISeq

+ func (s *StringSeq) ReduceInit(f IFn, init any) any

+ func (s *StringSeq) Seq() ISeq

+ func (s *StringSeq) String() string

+ func (s *StringSeq) WithMeta(meta IPersistentMap) any

+ type SubVector struct

+ func NewSubVector(meta IPersistentMap, v IPersistentVector, start, end int) *SubVector

+ func (v *SubVector) ApplyTo(args ISeq) any

+ func (v *SubVector) Assoc(key, val interface{}) Associative

+ func (v *SubVector) AssocN(i int, val interface{}) IPersistentVector

+ func (v *SubVector) Cons(val interface{}) Conser

+ func (v *SubVector) ContainsKey(key interface{}) bool

+ func (v *SubVector) Count() int

+ func (v *SubVector) Empty() IPersistentCollection

+ func (v *SubVector) EntryAt(key interface{}) IMapEntry

+ func (v *SubVector) Equals(v2 interface{}) bool

+ func (v *SubVector) Equiv(v2 interface{}) bool

+ func (v *SubVector) HashEq() uint32

+ func (v *SubVector) Invoke(args ...any) any

+ func (v *SubVector) IsEmpty() bool

+ func (v *SubVector) Length() int

+ func (v *SubVector) Meta() IPersistentMap

+ func (v *SubVector) Nth(i int) interface{}

+ func (v *SubVector) NthDefault(i int, def interface{}) interface{}

+ func (v *SubVector) Peek() interface{}

+ func (v *SubVector) Pop() IPersistentStack

+ func (v *SubVector) RSeq() ISeq

+ func (v *SubVector) Seq() ISeq

+ func (v *SubVector) ValAt(i interface{}) interface{}

+ func (v *SubVector) ValAtDefault(k, def interface{}) interface{}

+ func (v *SubVector) WithMeta(meta IPersistentMap) interface{}

+ type Symbol struct

+ func InternSymbol(ns, name interface{}) *Symbol

+ func NewSymbol(s string) *Symbol

+ func (s *Symbol) Equals(v interface{}) bool

+ func (s *Symbol) FullName() string

+ func (s *Symbol) Hash() uint32

+ func (s *Symbol) Meta() IPersistentMap

+ func (s *Symbol) Name() string

+ func (s *Symbol) Namespace() string

+ func (s *Symbol) String() string

+ func (s *Symbol) WithMeta(meta IPersistentMap) interface{}

+ type TimeoutError struct

+ func (e *TimeoutError) Error() string

+ func (e *TimeoutError) Is(other error) bool

+ type TransientMap struct

+ func (m *TransientMap) Assoc(k, v any) Associative

+ func (m *TransientMap) Conj(v any) Conjer

+ func (m *TransientMap) Persistent() IPersistentCollection

+ type TransientSet struct

+ func (s *TransientSet) Conj(v interface{}) Conjer

+ func (s *TransientSet) Persistent() IPersistentCollection

+ type TransientVector struct

+ func (t *TransientVector) ApplyTo(args ISeq) any

+ func (t *TransientVector) Assoc(key, val any) ITransientAssociative

+ func (t *TransientVector) AssocN(i int, val any) ITransientVector

+ func (t *TransientVector) Conj(o any) Conjer

+ func (t *TransientVector) Count() int

+ func (t *TransientVector) Invoke(args ...any) any

+ func (t *TransientVector) Nth(i int) any

+ func (t *TransientVector) NthDefault(i int, def any) any

+ func (t *TransientVector) Persistent() IPersistentCollection

+ func (t *TransientVector) Pop() ITransientVector

+ func (t *TransientVector) ValAt(i any) any

+ func (t *TransientVector) ValAtDefault(k, def any) any

+ type UnboundVar struct

+ func (uv *UnboundVar) String() string

+ type Var struct

+ func InternVar(ns *Namespace, sym *Symbol, root interface{}, replaceRoot bool) *Var

+ func InternVarName(nsSym, nameSym *Symbol) *Var

+ func InternVarReplaceRoot(ns *Namespace, sym *Symbol, root interface{}) *Var

+ func NewVar(ns *Namespace, sym *Symbol) *Var

+ func NewVarWithRoot(ns *Namespace, sym *Symbol, root interface{}) *Var

+ func (v *Var) AddWatch(key interface{}, fn IFn)

+ func (v *Var) AlterMeta(alter IFn, args ISeq) IPersistentMap

+ func (v *Var) AlterRoot(alter IFn, args ISeq) interface{}

+ func (v *Var) ApplyTo(args ISeq) interface{}

+ func (v *Var) BindRoot(root interface{})

+ func (v *Var) Deref() interface{}

+ func (v *Var) Get() interface{}

+ func (v *Var) HasRoot() bool

+ func (v *Var) Hash() uint32

+ func (v *Var) Invoke(args ...interface{}) interface{}

+ func (v *Var) IsBound() bool

+ func (v *Var) IsMacro() bool

+ func (v *Var) IsPublic() bool

+ func (v *Var) Meta() IPersistentMap

+ func (v *Var) Namespace() *Namespace

+ func (v *Var) RemoveWatch(key interface{})

+ func (v *Var) Set(val interface{}) interface{}

+ func (v *Var) SetDynamic() *Var

+ func (v *Var) SetMacro()

+ func (v *Var) SetMeta(meta IPersistentMap)

+ func (v *Var) SetValidator(vf IFn)

+ func (v *Var) String() string

+ func (v *Var) Symbol() *Symbol

+ func (v *Var) Validator() IFn

+ func (v *Var) Watches() IPersistentMap

+ type Vector struct

+ func NewVector(values ...any) *Vector

+ func (v *Vector) ApplyTo(args ISeq) any

+ func (v *Vector) AsTransient() ITransientCollection

+ func (v *Vector) Assoc(key, val any) Associative

+ func (v *Vector) AssocN(i int, val any) IPersistentVector

+ func (v *Vector) Cons(x any) Conser

+ func (v *Vector) ContainsKey(key any) bool

+ func (v *Vector) Count() int

+ func (v *Vector) Drop(n int) Sequential

+ func (v *Vector) Empty() IPersistentCollection

+ func (v *Vector) EntryAt(key any) IMapEntry

+ func (v *Vector) Equals(v2 any) bool

+ func (v *Vector) Equiv(v2 any) bool

+ func (v *Vector) HashEq() uint32

+ func (v *Vector) Invoke(args ...any) any

+ func (v *Vector) IsEmpty() bool

+ func (v *Vector) KVReduce(f IFn, init any) any

+ func (v *Vector) Length() int

+ func (v *Vector) Meta() IPersistentMap

+ func (v *Vector) Nth(i int) any

+ func (v *Vector) NthDefault(i int, def any) any

+ func (v *Vector) Peek() any

+ func (v *Vector) Pop() IPersistentStack

+ func (v *Vector) RSeq() ISeq

+ func (v *Vector) Reduce(f IFn) any

+ func (v *Vector) ReduceInit(f IFn, init any) any

+ func (v *Vector) Seq() ISeq

+ func (v *Vector) String() string

+ func (v *Vector) ValAt(i any) any

+ func (v *Vector) ValAtDefault(k, def any) any

+ func (v *Vector) WithMeta(meta IPersistentMap) any

+ type Volatile struct

+ func NewVolatile(val interface{}) *Volatile

+ func (v *Volatile) Deref() interface{}

+ func (v *Volatile) Reset(val interface{}) interface{}

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL