lang

package

Go to main page

Versions in this module

v0

v0.6.4

Oct 11, 2025

v0.6.3

Sep 25, 2025

v0.6.2

Sep 23, 2025

v0.6.1

Sep 20, 2025

Changes in this version

type Keyword

+ func (k Keyword) Sym() *Symbol

type NumberMethods

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

type Symbol

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

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

v0.6.0

Sep 20, 2025

Changes in this version

+ 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 ITransientMap interface

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) Xor(x, y any) any

type PersistentHashMap

+ func (m *PersistentHashMap) Hash() uint32

type PersistentStructMap

+ func (m *PersistentStructMap) Hash() uint32

type Set

+ func (s *Set) Hash() uint32

type Vector

+ func (v *Vector) Hash() uint32

v0.5.1

Sep 8, 2025

Changes in this version

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

type ISeq

+ func AllNamespaces() ISeq

+ 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 Set

+ func NewSet2(vals ...interface{}) (*Set, error)

v0.5.0

Sep 6, 2025

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